Enterprise Developer

Windows Azure Training Kit April 2013 Released

SQLDenis — Mon, 29 Apr 2013 18:28:00 +0000

Microsoft has released the Windows Azure Training Kit April 2013.

The Windows Azure Training Kit includes a comprehensive set of technical content designed to help you learn how to use Windows Azure. The kit includes hands-on labs, presentations, demos, and code samples for every aspect of developing applications for Windows Azure. You can use the resources in the training kit to teach yourself or train others.

There have been a number of improvements in this release alongside the refresh to the Infrastructure Services content including:

New Presentation: Windows Azure Mobile Services and Android
New Lab: Windows Azure Mobile Services and Android
New Lab: Windows Azure Mobile Services and Windows Phone
New Presentation: Introduction to Windows Azure HDInsight Service
New Lab: Introduction to Windows Azure HDInsight
Updated ITPro Content + Agenda
Updated Presentations for new feature support Windows Azure Overview, Windows Azure Web Sites, Windows Azure Virtual Machines & Windows Azure Mobile Services.

Hands-on Labs

Windows Azure Service Bus Remoting (VS2012): This hands-on lab walks you through this scenario using a sample application that replicates, albeit in a simplistic manner, the application architecture at Fictional Bank.

Node.js & Windows Azure Web Sites (OSX): In this hands-on lab, you will learn the basics of the Windows Azure Web Sites service for Node.js applications.

PHP & Windows Azure Web Sites (OSX): In this hands-on lab, you will explore the basic elements of the Windows Azure Web Sites service by creating a simple PHP application and deploying it using FTP deployment.

Windows Azure Web Sites Gallery (OSX): In this hands-on lab you will learn how to create a new web site in Windows Azure by using a template from the pre-packaged applications gallery.

Download it here: http://www.windowsazure.com/en-us/develop/net/other-resources/training-kit/

Original post blogged on LessThanDot.

Windows 8 for the Enterprise Event - Tuesday, April 16th

Ted Krueger (onpnt) — Tue, 09 Apr 2013 18:58:00 +0000

I’ve had the chance to talk to quite a few people over the last few months about my experiences with Windows 8. So far, and I can’t see it changing, I’ve been very impressed with Windows 8 and the efficiency boost it has provided me in normal, day-to-day operations. I’ve cut down the time it takes to manage how I utilize a machine. This includes even simple operations like Windows management.

This isn’t about how much faster Windows 8 can make you though. Well, in a way it is. What I wanted to let everyone know about is an upcoming event that BlueMetal and Microsoft together will be providing to anyone that wants to attend – Windows 8 for the Enterprise – Demo Day.

BlueMetal in Chicago is on the front lines of Window 8 development. Some of the most effective, efficient and promising business-impacting solutions are coming from BlueMetal in the form of Windows 8 development. This has been around much tablet work as well. It takes a lot to impress me, given how many applications or systems I’ve seen that promise to fix the world of computing. I can honestly say, the Windows 8 development coming from BlueMetal will make businesses function more effectively.

To find out how this all happens, evolves and is put to work, attend this event. BTW...It's FREE and all are welcome!

Below is the link to register and the event details - click the image to register.

Original post blogged on LessThanDot.

Windows Azure Training Kit available

SQLDenis — Mon, 25 Feb 2013 23:39:00 +0000

Microsoft has made available the Windows Azure Training Kit

The Windows Azure Training Kit includes hands-on labs, presentations, and samples to help you understand how to build applications that use Windows Azure.

Hands-on labs are sets of step-by-step guides that are designed to help you learn how to use key Windows Azure services and features. Each Lab provides instructions to guide you through the process of developing a complete application. The cool thing is that you can contribute to any of these hands-on labs by forking their repositories on GitHub and make changes to the content. Once you've made your changes, share them back with the community by sending a pull request.

Demos are sets of step-by-step guides that are designed to demonstrate how to use key Windows Azure services and features.

Presentations are a set of resources you can use for learning Windows Azure capabilities or to present Windows Azure features to an audience at a conference.

You can get all the goodies here: http://windowsazure-trainingkit.github.com/index.htm

Original post blogged on LessThanDot.

Displaying .Net Build Warnings in TeamCity

Eli Weinstock-Herman (tarwn) — Tue, 15 Jan 2013 13:41:00 +0000

I like it when I kick off a build and there aren't any warnings. Unfortunately I'm forgetful and it's always easier to edit the code now then it is 3 months later (when I remember to look at the warnings). When I put together my sample Continuous Delivery project, I was using Jenkins, which provided plugins for capturing warnings. It was nice to have visual feedback when I added a new warning, see how many were outstanding, have a list of outstanding warnings available on demand, and when I had a few minutes and fixed some of them, positive feedback by watching the warning chart slowly go down.

When I switch modes and work in TeamCity, I miss having that information available, with no extra steps from me. Despite several searches, though, I was never able to find a plugin that duplicated that behavior I liked in the Jenkins plugin. Turns out that TeamCity makes it pretty easy to roll your own, with just a little bit of powershell and some built-in features.

In this post I am going to cover capturing the warnings from an MSBuild build step, adding that warning count to the main dashboard, adding a statistics chart for the warning count over time, adding a condensed list to the end of the build log, adding the formatted list as a build artifact, and adding a custom report tab to report the warnings for each build.

Because who doesn't need five different ways to see their warnings?

Capturing the Build Warnings

Since I am using MSBuild, the build warnings have a consistent pattern and MSBuild itself has an option to log out to a logger. We can add this attribute in either the build step or the Build Parameters. My preference is using the parameters of the build step in case I have multiple MSBuild calls in the build.

Parameter to add to MSBuild: /l:FileLogger,Microsoft.Build.Engine;logfile=%BuildLogFilename%

Adding the MS Build Parameter

Each time MSBuild runs, it will log it's output to the specified file. We can use powershell to extract the warnings from the output, like so:

powershell

Line number Off | Hide | Select all

Param(
[parameter(Mandatory=$true)]
[alias("f")]
$FilePath
)
$warnings = @(Get-Content -ErrorAction Stop $FilePath | # Get the file content
Where {$_ -match '^.*warning CS.*$'} | # Extract lines that match warnings
%{ $_.trim() -replace "^\s*\d+>","" } | # Strip out any project number and caret prefixes
sort-object | Get-Unique -asString) # remove duplicates by sorting and filtering for unique strings

Once we have the warnings extracted, we can move on to decide how we want them delivered.

Each section below will continue to add on to this script until it contains all the pieces we need to meet the display goals at the beginning.

Condensed Warning List in Build Log

The powershell script that is extracting warnings will need to run as a build step in the appropriate build configuration. This means that displaying a formatted list of warnings at the end of the build log is as simple as outputting that list from the powershell script we are building.

powershell

Line number Off | Hide | Select all

$count = $warnings.Count
Write-Host "MSBuild Warnings - $count warnings ==================================================="
$warnings | % { Write-Host " * $_" }

This will output a section at the bottom of the build log that contains our warnings, like so:

Warnings in the Bottom of a Build Log

Which I suppose is fine, but doesn't really add that much value over the ones listed further up the log by MSBuild itself.

Condensed Warning List in Archived Text File

Now that I have formatted warnings, it's pretty easy to create a file with those warnings and archive it. First I'll update the script to take an output parameter and add some file output:

powershell

Line number Off | Hide | Select all

Param(
[parameter(Mandatory=$true)]
[alias("f")]
$FilePath,
[parameter()]
[alias("o")]
$RawOutputPath,
)
# ...
# file output
if($RawOutputPath){
$stream = [System.IO.StreamWriter] $RawOutputPath
$stream.WriteLine("Build Warnings")
$stream.WriteLine("====================================")
$stream.WriteLine("")
$warnings | % { $stream.WriteLine(" * $_") }
$stream.Close()
}

Then I'll configure the project to capture that output file as an artifact:

Artifact Configuration

Et voila, the file shows up in my archived items:

List of archived items from a run

And I have a clean, archived list of my warnings:

Display of archived text file

But, really, we can do better.

Warning count in build status

Part of the goal was to be able to see the warning count change with no extra work, the best place I can think of to meet this is the final build status on each build.

Before:

Build status on dashboard

TeamCity provides support for setting the build status from a build script. By adding some output to the powershell script, like so:

powershell

Line number Off | Hide | Select all

#TeamCity output
Write-Host "##teamcity[buildStatus text='{build.status.text}, Build warnings: $count']"

Each successful build will also display the number of warnings that were captured.

Build status on dashboard, with warnings

Better, but what about historical values? And I still don't like that text file artifact.

Warning Count as a Custom Chart

TeamCity also provides the ability to add custom charts based on either built-in or custom statistics. Custom statistics are reported similar to the build status output above:

powershell

Line number Off | Hide | Select all

Write-Host "##teamcity[buildStatisticValue key='buildWarnings' value='$count']"

Adding a custom chart requires us to dig into the configurations of TeamCity. I'm going to add a chart that will be displayed for any build that provides the warning count number above, so I'll open the [teamCity data dir]/config/main-config.xml file and add the following section:

powershell

Line number Off | Hide | Select all

This will add a chart to the Statistics tab of the build. After a few builds this is what I have:

Build Warning Statistics

It probably would look better if I hadn't built with the same number of warnings each time, but you get the point. The mouse hover works just like the built-in charts, linking to the run status for the individual point.

Ok, getting better, but I think we can take it one step further.

Adding a Custom Build Warnings Tab

So far we have improved methods of seeing the warning count and watching how it changes over time, but the actual list still leaves something to be desired. Luckily, TeamCity supports custom report tabs in the Build Results. This gives us an easily accessible place to put the warnings and, since it uses HTML, better formatting options than the text file.

First I need to update the powershell script to output the HTML file. TeamCity will be picking up an entire folder for the report tab, so I could add some external CSS or image files for my report, but I'll leave that for another day.

powershell

Line number Off | Hide | Select all

# html report output
$check = Test-Path -PathType Container BuildWarningReport
if($check -eq $false){
New-Item 'BuildWarningReport' -type Directory
}
$stream = [System.IO.StreamWriter] "BuildWarningReport/index.html"
$stream.WriteLine("
$count Build Warnings
")
$stream.WriteLine("
- $warnings | % { $stream.WriteLine("
- $_
- $stream.WriteLine("
")
$stream.WriteLine("")
$stream.Close()

I've added HTML output to the script with a hardcoded output location that ensures the report directory exists before writing the index.html page. I've hardcoded this value to reduce the amount of thinking 'll need to do as I add this to other projects (keeps it consistent from output name to artifact setting to report tab configuration).

The next step is to configure the project to capture the folder as an artifact:

Artifact configuration

Then the last step is to modify the TeamCity configuration to recognize that when I output archives like that, I want to treat them as a report. To do this I add the following chunk of XML to my [TeamCity data directory]/config/main-config.xml file (per the documentation link above):

xml

Line number Off | Hide | Select all

title="Build Warnings" basePath="BuildWarningReport" startPage="index.html" />

And there we go, the custom report tab is available in the build results:

Build Warnings tab in Run Results

Which takes us from no visibility into our warnings, to five different methods of viewing the information.

Wrap-up

From having to Ctrl+F through the build log all the way to plugin-level output in a few easy steps. After setting this up one time, the only pieces that needed to be repeated for additional builds are the addition of the /logger parameter for MSBuild and the powershell build step to extract the results, and capturing the artifact for the HTML page. All of the output is either built in to the script or applies to the whole server and is displayed whenever the statistics or archive are present in a build.

Here is the finished script:

powershell

Line number Off | Hide | Select all

Param(
[parameter(Mandatory=$true)]
[alias("f")]
$FilePath,
[parameter()]
[alias("o")]
$RawOutputPath
)
$warnings = @(Get-Content -ErrorAction Stop $FilePath | # Get the file content
Where {$_ -match '^.*warning CS.*$'} | # Extract lines that match warnings
%{ $_.trim() -replace "^\s*\d+>","" } | # Strip out any project number and caret prefixes
sort-object | Get-Unique -asString) # remove duplicates by sorting and filtering for unique strings
$count = $warnings.Count
# raw output
Write-Host "MSBuild Warnings - $count warnings ==================================================="
$warnings | % { Write-Host " * $_" }
#TeamCity output
Write-Host "##teamcity[buildStatus text='{build.status.text}, Build warnings: $count']"
Write-Host "##teamcity[buildStatisticValue key='buildWarnings' value='$count']"
# file output
if($RawOutputPath){
$stream = [System.IO.StreamWriter] $RawOutputPath
$stream.WriteLine("Build Warnings")
$stream.WriteLine("====================================")
$stream.WriteLine("")
$warnings | % { $stream.WriteLine(" * $_") }
$stream.Close()
}
# html report output
$check = Test-Path -PathType Container BuildWarningReport
if($check -eq $false){
New-Item 'BuildWarningReport' -type Directory
}
$stream = [System.IO.StreamWriter] "BuildWarningReport/index.html"
$stream.WriteLine("
$count Build Warnings
")
$stream.WriteLine("
- $warnings | % { $stream.WriteLine("
- $_
- $stream.WriteLine("
")
$stream.WriteLine("")
$stream.Close()

To recap, we started with some warning messages randomly scattered across the build log. We ended with the warning count automatically showing in the build status on the dashboard, a nice chart of the number over time, and three different ways to view the detailed list. I hope this proves useful to others as well, now I have to go and fix the sample warnings I added before I forget about them.

Original post blogged on LessThanDot.

Scala: The difference between val and var

SQLDenis — Sat, 12 Jan 2013 10:25:00 +0000

This is a short Scala post to explain what the difference is between val and var. I was showing some Scala code to a co-worker this past week and he was asking what the difference was between val and var. It is quite simple:

val defines a fixed value, it is a read only variable
var defines a mutable variable, this variable can be modified

In Java you would use final to create a variable which would be read only, this is the same as val in Scala.

Let's look at some very simple Scala code.

Code: scala

object Test {

def main(args: Array[String]) = println("done with main")

var Test1 =5
println("Test1 " + Test1)

Test1 = 6
println("Test1 " + Test1)

}

Running the code above will give the following output
Test1 5
Test1 6
done with main

If you are trying to use val, you will get an error, change var to val and see if you can compile the code

Code: scala

object Test {

def main(args: Array[String]) = println("done with main")

val Test1 =5
println("Test1 " + Test1)

Test1 = 6
println("Test1 " + Test1)

}

Here is the error, the code won't even compile

Description		Resource	Path		Location	Type
reassignment to val	Test.scala	/ScalaTemp/src	line 8		Scala Problem

So as you can see, val is read only, while with var you can modify the variable.

If you want to play around with Scala, take a look at Installing Scala 2.10 on Eclipse Juno

Original post blogged on LessThanDot.

Review of The Well-Grounded Java Developer

SQLDenis — Wed, 09 Jan 2013 15:12:00 +0000

This is a review of The Well-Grounded Java Developer, Vital techniques of Java 7 and polyglot programming. Written by Benjamin J. Evans and Martijn Verburg. The book was published in July, 2012 and it contains 496 pages

Right from the start I want to say that this is an excellent book and I highly recommend it. One thing you do need to be aware about is that in order to use this book you need to know Java. If you don't know Java then this is not the book for you. This book is all about bringing you to the next level as a Java developer by showing you how to do continuous integration, dependency injection, testing, performance tuning, and more.
This book even shows you how to use different languages that run on the JVM. The book is written in a easy and concise style, everything is very clear. I also love the annotations which are sprinkled throughout the book, they give some nice background information. While the chapters on Groovy, Scala and Clojure are not a complete reference for the language, they do provide enough material to form a nice foundation, now you can further explore the language on your own.

The book is split up in four parts, I will list each part with the chapters within that part and will give a brief summary what the part is about

Part 1 Developing with Java 7
Chapter 1 Introducing Java 7
Chapter 2 New I/O

This section shows you what was added in Java 7, for example you can now use strings in switch statements, try-with-resources(similar to a using statement in c#, it frees up the resources after it is done). The Java IO stuff has been rewritten and much easier to use, where you had to write a whole bunch of code before, you can now do the same in much less code. Some things that did not exist in Java in terms of IO but now does exist are explained as well.

Part 2 Vital techniques
Chapter 3 Dependency Injection
Chapter 4 Modern concurrency
Chapter 5 Class files and bytecode
Chapter 6 Understanding performance tuning

This part has a lot of stuff and as a Java developer you should really know how this stuff works if you want to get to the next level. Dependency Injection(DI) and inversion of control (IoC) are covered, Guice 3, the reference implementation for DI in Java is also covered. Concurrency before Java 5 and concurrency now is covered. Concurrency will be a must now that we have multi-CPU and multi-core everywhere, you better get your wits around it. There is a whole chapter on the class files itself and how they are loaded as well as what they compile into. These are fun details and will show you exactly what happens when you compile and execute a class. Evereybody's favorite subject performance tuning is covered in this part of the book as well.

Part 3 Polyglot programming on the JVM
Chapter 7 Alternative JVM languages
Chapter 8 Groovy: Java’s dynamic friend
Chapter 9 Scala: powerful and concise
Chapter 10 Clojure: safer programming

This is a very interesting part of the book and I would suggest not to skip it. There are 3 type of languages covered in this part:
Groovy, a dynamic language
Scala, a functional language
Clojure, a Lisp for functional programming

Take a look at these languages and you will be amazed how much Java boilerplate code you can eliminate by using these languages instead. Some of the functional is a little bit of a paradigm shift and you might need some time adjusting. You will also see how you can interoperate between these languages and Java.

Part 4 Crafting the polyglot project
Chapter 11 Test-driven development
Chapter 12 Build and continuous integration
Chapter 13 Rapid web development
Chapter 14 Staying well-grounded

The last part is all about automation and making your life easier. If you are a developer who still deploys stuff by using FTP to move JAR, EAR and WAR files, pay attention. Maven is covered as the build automation tool, Jenkins is the continuous integration tool. In the Rapid web development chapter Grails is explored.

Let me just repeat again that I think this is an awesome book and as a Java developer you have to check it out. The one thing that is missing from the book is ORM, it is covered a little in the testing chapter but if you want to know about ORM, you will need to pick out some other book just for that.

You can download the following chapters to get a feel for the book

Sample chapter 1
Sample chapter 4

Head on over to Amazon for other reviews of The Well-Grounded Java Developer, Vital techniques of Java 7 and polyglot programming
The site for the book can be found here: http://www.manning.com/evans/

Below is the complete table of contents so that you have a little more details about each chapter.

Part 1 Developing with Java 7
Chapter 1 Introducing Java 7
The language and the platform
Small is beautiful—Project Coin
The changes in Project Coin
Summary

Chapter 2 New I/O
Java I/O—a history
Path—a foundation of file-based I/O
Dealing with directories and directory trees
Filesystem I/O with NIO.2
Asynchronous I/O operations
Tidying up Socket-Channel functionality
Summary

Part 2 Vital techniques
Chapter 3 Dependency Injection
Inject some knowledge—understanding IoC and DI
Standardized DI in Java
Guice 3—the reference implementation for DI in Java
Summary

Chapter 4 Modern concurrency
Concurrency theory—a primer
Block-structured concurrency (pre-Java 5)
Building blocks for modern concurrent applications
Controlling execution
The fork/join framework
The Java Memory Model (JMM)
Summary

Chapter 5 Class files and bytecode
Classloading and class objects
Using method handles
Examining class files
Bytecode
Invokedynamic
Summary

Chapter 6 Understanding performance tuning
Performance terminology—some basic definitions
A pragmatic approach to performance analysis
What went wrong? Why we have to care
A question of time—from the hardware up
Garbage collection
JIT compilation with HotSpot
Summary

Part 3 Polyglot programming on the JVM
Chapter 7 Alternative JVM languages
Java too clumsy? Them’s fighting words!
Language zoology
Polyglot programming on the JVM
How to choose a non-Java language for your project
How the JVM supports alternative languages
Summary

Chapter 8 Groovy: Java’s dynamic friend
Getting started with Groovy
Groovy 101—syntax and semantics
Differences from Java—traps for new players
Groovy features not (yet) in Java
Interoperating between Groovy and Java
Summary

Chapter 9 Scala: powerful and concise
A quick tour of Scala
Is Scala right for my project?
Making code beautiful again with Scala
Scala’s object model—similar but different
Data structures and collections
Introduction to actors
Summary

Chapter 10 Clojure: safer programming
Introducing Clojure
Looking for Clojure—syntax and semantics
Working with functions and loops in Clojure
Introducing Clojure sequences
Interoperating between Clojure and Java
Concurrent Clojure
Summary

Part 4 Crafting the polyglot project
Chapter 11 Test-driven development
TDD in a nutshell
Test doubles
Introducing ScalaTest
Summary

Chapter 12 Build and continuous integration
Getting started with Maven 3
Maven 3—a quick-start project
Maven 3—the Java7developer build
Jenkins—serving your CI needs
Code metrics with Maven and Jenkins
Leiningen
Summary

Chapter 13 Rapid web development
The problem with Java-based web frameworks
Criteria in selecting a web framework
Getting started with Grails
Grails quick-start project
Further Grails exploration
Getting started with Compojure
A sample Compojure project—“Am I an Otter or Not?”
Summary

Chapter 14 Staying well-grounded
What to expect in Java 8
Polyglot programming
Future concurrency trends
New directions in the JVM

Original post blogged on LessThanDot.

Installing Scala 2.10 on Eclipse Juno

SQLDenis — Sat, 05 Jan 2013 13:46:00 +0000

As part of my resolutions for the year I said I would write more blog posts and also get into different technology. I decided to take a look at Scala. Well it turns out Scala 2.10 was released yesterday. But first what is Scala anyway? From the Scala site:

Scala is a general purpose programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages, enabling Java and other programmers to be more productive. Code sizes are typically reduced by a factor of two to three when compared to an equivalent Java application.

Scala is an object oriented, functional, statically typed language. You could probably compare it to F# if you are a .NET programmer.

The first thing you have to do is downloading version 2.10 of Scala, you can download that version here: http://www.scala-lang.org/downloads

After it is downloaded and installed, it is time to get the Eclipse plugin for Scala 2.10

The way you do this is you click on Help followed by Install New Software... from the menu in Eclipse

Click on the Add button

For Eclipse Juno you need to use the following URL in the location box http://download.scala-ide.org/sdk/e38/scala210/dev/site/
For Eclipse Indigo use the following URL http://download.scala-ide.org/sdk/e37/scala210/dev/site/
Give a name for the repository, I named mine Scala 10 for Eclipse Juno. Hit Ok

Hit next

On the Install Details form you will see Scala IDE for Eclipse
You can expand it to reveal the following

Hit next to accept the license, hit finish.

Now Eclipse will ask you to restart. After Eclipse is restarted it is time to create our first Scala application
From the menu go to File and then select New Project. Navigate to Scala Wizards and select Scala Project

Now that the project is created let's create a simple object

Right click on the Scala Project from the package Explorer and select New--> Scala Object

Give it a name and check public static void main

You should have something like this

Code: scala

object Test2 {

def main(args: Array[String]): Unit = {}

}

Let's make it more interesting by generating some output

Code: scala

object Test2 {

def main(args: Array[String]): Unit = {}

val (name, site, role) = getSomeInfo()
println("Name is " + name)
println("Site is " + site)
println("Role is " + role)

def getSomeInfo() = {
("SQLDenis", "LessThanDot", "blogger")
}
}

Run it by selecting Run As--> Scala Application from the Run as button

Your output should be the following
Name is SQLDenis
Site is LessThanDot
Role is blogger

Why don't we add a simple loop to our code? Here is what needs to be added

Code: scala

for (i <- 1 to 3) {
print(i + ",")
}
println(" Testing 1,2,3.....")

Here is the whole code

Code: scala

object Test2 {

def main(args: Array[String]): Unit = {}

val (name, site, role) = getSomeInfo()
println("Name is " + name)
println("Site is " + site)
println("Role is " + role)

for (i <- 1 to 3) {
print(i + ",")
}
println(" Testing 1,2,3.....")

def getSomeInfo() = {
("SQLDenis", "LessThanDot", "blogger")
}
}

Run it again, here is what the output should be

Name is SQLDenis
Site is LessThanDot
Role is blogger
1,2,3, Testing 1,2,3.....
Here is what my Eclipse window looks like

In case you are interested in all the new stuff in Scala 2.10, take a look at the stuff below.

The Scala 2.10.0 codebase includes the following new features and changes:

Value Classes
- A class may now extend AnyVal to make it behave like a struct type (restrictions apply).
- http://docs.scala-lang.org/overviews/core/value-classes.html
Implicit Classes
- The implicit modifier now also applies to class definitions to reduce the boilerplate of implicit wrappers.
- http://docs.scala-lang.org/sips/pending/implicit-classes.html
String Interpolation
- val what = "awesome"; println(s"string interpolation is ${what.toUpperCase}!")
- http://docs.scala-lang.org/overviews/core/string-interpolation.html
Futures and Promises
- Asynchronously get some JSON: for (req <- WS.url(restApiUrl).get()) yield (req.json \ "users").as[List[User]] (uses play!)
- http://docs.scala-lang.org/overviews/core/futures.html
Dynamic and applyDynamic
- x.foo becomes x.applyDynamic("foo") if x's type does not define a foo, but is a subtype of Dynamic
- http://docs.scala-lang.org/sips/pending/type-dynamic.html
Dependent method types:
- def identity(x: AnyRef): x.type = x // the return type says we return exactly what we got
New ByteCode emitter based on ASM
- Can target JDK 1.5, 1.6 and 1.7
- Emits 1.6 bytecode by default
- Old 1.5 backend is deprecated
A new Pattern Matcher
- rewritten from scratch to generate more robust code (no more exponential blow-up!)
- code generation and analyses are now independent (the latter can be turned off with -Xno-patmat-analysis)
Scaladoc Improvements
- Implicits (-implicits flag)
- Diagrams (-diagrams flag, requires graphviz)
- Groups (-groups)
Modularized Language features
- Get on top of the advanced Scala features used in your codebase by explicitly importing them.
- http://docs.scala-lang.org/sips/pending/modularizing-language-features.html
Parallel Collections are now configurable with custom thread pools
- http://docs.scala-lang.org/overviews/parallel-collections/overview.html
Akka Actors now part of the distribution
- The original Scala actors are now deprecated.
- See the actors migration project for more information.
Performance Improvements
- Faster inliner
- `Range#sum is now O(1)
- Update of ForkJoin library
- Fixes in immutable TreeSet/TreeMap
- Improvements to PartialFunctions
Addition of ??? and NotImplementedError
Addition of IsTraversableOnce + IsTraversableLike type classes for extension methods
Deprecations and cleanup
- Floating point and octal literal syntax deprecation
- Removed scala.dbc

Experimental features

The following exciting -- experimental -- features are part of 2.10.0:

Scala Reflection
- https://docs.google.com/document/d/1Z1VhhNPplbUpaZPIYdc0_EUv5RiGQ2X4oqp0i-vz1qw/edit#heading=h.pqwdkl
Macros
- http://docs.scala-lang.org/overviews/macros/overview.html

That is all for this post, Scala is just one of the languages I will explore in my quest to be more of a polyglot this year. Have you looked at Scala or some other functional language like F#?

Edit.......

And I played a little more with this and decided to do one of our Friday the Thirteenths

Here is a solution that someone posted in Java

Code: java

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;

public class Test
{
private static final DateFormat format = new SimpleDateFormat("EEE MMM dd yyyy");

public static void main(String... args) {
GregorianCalendar cal = new GregorianCalendar();
GregorianCalendar stopDate = new GregorianCalendar();
stopDate.add(Calendar.YEAR, 10);

// Move ahead to the next Friday
while (cal.get(Calendar.DAY_OF_WEEK) != 6) cal.add(Calendar.DATE, 1);

while (cal.before(stopDate)) {
if (cal.get(Calendar.DAY_OF_MONTH) == 13)
System.out.println(format.format(cal.getTime()));

cal.add(Calendar.DATE, 7);
}
}
}

In Scala you don't have to change that much, you can leave or take out the semicolons, here is the code

Code: scala

object Test2 {

import java.text.DateFormat
import java.text.SimpleDateFormat
import java.util.Calendar
import java.util.GregorianCalendar

def main(args: Array[String]): Unit = {}
val DateFormat = new SimpleDateFormat("EEE MMM dd yyyy")

val cal = new GregorianCalendar()
val stopDate = new GregorianCalendar()
stopDate.add(Calendar.YEAR, 10);

while (cal.get(Calendar.DAY_OF_WEEK) != 6) cal.add(Calendar.DATE, 1)

while (cal.before(stopDate)) {
if (cal.get(Calendar.DAY_OF_MONTH) == 13)
println(DateFormat.format(cal.getTime()))
cal.add(Calendar.DATE, 7);

}

}

And here is the output

Fri Sep 13 2013
Fri Dec 13 2013
Fri Jun 13 2014
Fri Feb 13 2015
Fri Mar 13 2015
Fri Nov 13 2015
Fri May 13 2016
Fri Jan 13 2017
Fri Oct 13 2017
Fri Apr 13 2018
Fri Jul 13 2018
Fri Sep 13 2019
Fri Dec 13 2019
Fri Mar 13 2020
Fri Nov 13 2020
Fri Aug 13 2021
Fri May 13 2022

With SQL Server, you can just use a number table

Code: tsql

SELECT DATEADD(m, number,'1998-01-13')
FROM master..spt_values WHERE type = 'P'
and DATENAME(dw,DATEADD(m, number,'1998-01-13')) = 'friday'

That is really it for this post...

Original post blogged on LessThanDot.

Auto-Verifying Moqs

Alex Ullrich — Thu, 20 Dec 2012 14:06:00 +0000

After years of only being familiar with Rhino mocks, I have been using Moq for the last 10 months or so. For the most part, I like it better. The syntax seems easier to get people up to speed on, and there are situations where it really cuts down on the amount of test code you have to write. This is about one of the situations where it doesn't.

One of the things I always liked about Rhino Mocks was the idea of the mock repository, and the fact that when disposing of a mock repository all of your setups get verified automagically. I have a lot of trouble remembering to add calls to VerifyAll when I'm adding functionality to existing tests because I got so used to this behavior in the past. When I noticed some tests where I had unnecessary mocks setup today I decided to do something about it. Its not really anything special but figued I'd share since I haven't posted for a while.

Basically I added a base test fixture to the project that provides a means to create tracked mocks (similar to the MockRepository concept in Rhino). It provides a method for mock creation, and adds all created mocks to a list that is then verified in the teardown method. Pretty simple stuff but I found it handy.

Code: csharp

using System.Collections.Generic;
using Moq;
using NUnit.Framework;

namespace Project.Tests
{
public abstract class MockVerifyingTest
{
readonly List<Mock> _trackedMocks = new List<Mock>();

protected Mock<T> GenerateTrackedMock<T>(MockBehavior mockBehavior = MockBehavior.Default) where T : class
{
var mock = new Mock<T>(mockBehavior);
_trackedMocks.Add(mock);
return mock;
}

[TearDown]
public virtual void TearDown()
{
try
{
foreach (var mock in _trackedMocks)
{
mock.VerifyAll();
}
}
finally
{
_trackedMocks.Clear();
}
}
}
}

So now instead of something like this:

Code: csharp

[Test]
public void ATest()
{
var foo = new Mock<IFoo>(MockBehavior.Strict);

foo.Setup(f => f.GetSomething()).Returns(new Something());

var bar = new Bar(foo);

bar.CodeUnderTest();

foo.VerifyAll();
}

I can have my fixture inherit from MockVerifyingTest and write it like this:

Code: csharp

[Test]
public void ATest()
{
var foo = GenerateTrackedMock<IFoo>(MockBehavior.Strict);

foo.Setup(f => f.GetSomething()).Returns(new Something());

var bar = new Bar(foo);

bar.CodeUnderTest();
}

It only saves one line of test code in this example, but it can add up when dealing with tests that have several mocks. I realize having this many mocks in play for a test is just asking for trouble, but I am dealing with a legacy system without any test coverage, so working in test coverage without any sweeping refactorings is imperative at this point. We can make those changes later once we've gotten through a release or two with the code that is now under test

Original post blogged on LessThanDot.

Java Training Day 5

SQLDenis — Sat, 01 Dec 2012 00:41:00 +0000

Last day of the training and I am glad it is over...this stuff is draining

Here is what was covered today

Network Programming
Low Level TCP/IP Protocols
IPv4 and IPv6
UDP Multicast
TCP/IP

Message Based protocols
HTTP
Connections framework using URL (Unified Resource Locator)

Remote Objects
RMI (Remote Method Invocation)
CORBA (Common Object Request Broker Architecture)

Optional packages supporting additional protocols
SOAP, Mail etc etc

We talked about port numbers, here are some common ones that you might know

20 & 21: File Transfer Protocol (FTP)
22: Secure Shell (SSH)
23: Telnet remote login service
25: Simple Mail Transfer Protocol (SMTP)
53: Domain Name System (DNS) service
80: Hypertext Transfer Protocol (HTTP)
110: Post Office Protocol (POP3)
119: Network News Transfer Protocol (NNTP)
143: Internet Message Access Protocol (IMAP)
161: Simple Network Management Protocol (SNMP)
443: HTTP Secure (HTTPS)

Threads
In an operating process, each running program is basically a process
The operating system schedules processes for execution
Each process has its own (virtual) address space
Communications between processes is hampered by context switching

A thread is a flow of execution within a java process
The JVM schedules therads for execution
Threads share access to java objects
Communication between threads is quick

On multi-CPU/multi-core machines, several threads can execute at the same time

Executing with threads
One thread is started automatically to execute main()
The main() method may start additional threads
Single threaded applications run until main() terminates
Multi threaded applications run until all threads have terminated or if one of the threads calls System.exit()

Static methods manipulate the current thread
currentThread() returns a refernce to the thread that is currently executing
yield() pauses the currently executing thread
sleep(int ms) blocks the currently executing thread for a specific milliseconds

Instance methods that manipulate a particular thread
start() starts thread execution
getName() gets the name of the thread
interrupt() throws an exception or sets the interrupt status
join() waits for the thread to die
setPriority set the priority for a thread

The run() method will hold the code to be executed by a thread

The stop(), suspend() and resume() methods are deprecated

Local variables are never shared between threads, threads can share memory on the heap like static variables, instance variables and members of arrays
We covered synchronization, thread scheduling

JDBC
WE covered the regular DB related stuff, how to connect to a DB, explanation what the 4 type of jdbc drivers are, executing, statements, prepared statements and stored procedures

Web programming
We covered servlets, JSP, javabeans, struts, mvc...pretty much similar stuff I was doing in 2001 but now we have many more frameworks to makes things easier

Original post blogged on LessThanDot.

Java Training Day 4

SQLDenis — Thu, 29 Nov 2012 18:55:00 +0000

Today was day four of our Java training, we looked at generics, collection and IO today, here is what was covered

The Collections Framework
Legacy Container Classes
A container is an object that holds a collection of other objects
An array is a simple container. Arrays have a couple of limitations
. The size is fixed
. All the members of the array must be of the same type
. You can't add methods and attributes to an array

The java.util package has two container classes as well as an supporting interface

Vector class
Has add() and remove() methods, the elementAt() method let's you retrieve an element at a specified index
The Stack subclass provides the push() and pop() methods, this will support a LIFO stack

Hashtable class
This is an expandable associative array
The entries are stored as key/value pairs, no dups allowed
The Properties subclass will hold the name/value pairs

The Enumeration interface can be used to traverse either the vector or the hashtable objects. Enumeration has hasMoreElements() and nextElements() methods

Legacy Container Classes Disadvantages
It is not type safe, the containers can hold any kind of objects
The references must be downcast explicitly if you want to access the objects
They are synchronized, performance hit
Code needs to be rewritten if you want to replace one container with a container from another type

Vector, Hashtable and the Enumeration interface in Java SE 5+
Vector, Hashtable and the Enumeration interface have been redefined as generics
Vector is now Vector<E> and it implements the List<E>> interface
Hashtable is now Hashtable <K,V> and implements the Map<K ,V> interface
Enumeration is now Enumeration <E>.
Enumeration has been superseded by the Iterator interface

The enhanced for loop (or for each loop) works automatically with the generic versions of the containers

Collections Framework
The Collections Framework is a unified framework fo manipulating collections of objects
Programmers can choose from a variety of structures

The collections framework consists of:

Collection Interfaces - Represent different types of collections, such as sets, lists and maps. These interfaces form the basis of the framework.
General-purpose Implementations - Primary implementations of the collection interfaces.
Legacy Implementations - The collection classes from earlier releases, Vector and Hashtable, have been retrofitted to implement the collection interfaces.
Special-purpose Implementations - Implementations designed for use in special situations. These implementations display nonstandard performance characteristics, usage restrictions, or behavior.
Concurrent Implementations - Implementations designed for highly concurrent use.
Wrapper Implementations - Add functionality, such as synchronization, to other implementations.
Convenience Implementations - High-performance "mini-implementations" of the collection interfaces.
Abstract Implementations - Partial implementations of the collection interfaces to facilitate custom implementations.
Algorithms - Static methods that perform useful functions on collections, such as sorting a list.
Infrastructure - Interfaces that provide essential support for the collection interfaces.
Array Utilities - Utility functions for arrays of primitives and reference objects. Not, strictly speaking, a part of the Collections Framework, this functionality was added to the Java platform at the same time and relies on some of the same infrastructure.

Collection Implementations
The general purpose implementations are summarized in the table below:

		Implementations
		Hash Table	Resizable Array	Balanced Tree	Linked List	Hash Table + Linked List
Interfaces	Set	`HashSet`		`TreeSet`		`LinkedHashSet`
	List		`ArrayList`		`LinkedList`
	Deque		`ArrayDeque`		`LinkedList`
	Map	`HashMap`		`TreeMap`		`LinkedHashMap`

Code to the interface, not to the class, you can now change the container without having to make code changes

Code: java

ArrayList<Integer> list = new ArrayList<Integer>();
LinkedList<Integer> list = new LinkedList<Integer>();

Code: java

List<Integer> list = new ArrayList<Integer>();
List<Integer> list = new LinkedList<Integer>();

There is a tutorial availabe on the Oracle website here: http://docs.oracle.com/javase/tutorial/collections/index.html

Exceptions

Traditional
Inefficient, checks must be done even if stuff doesn't blow up
Difficult to maintain
Using a return value as both an output value and an error status is confusing
Compiler does not enforce error checking

Using Exceptions
Compiler can enforce proper exception handling
Exception is caught by a block designed to handle the exception
Errors cause by constructors, initializers and other code that doesn't return a return value

All exceptions objects are subclasses of java.lang.Throwable and they inherit its methods
Error, Exception and RuntimeException are treated differently by the compiler
Error, this mean as major system-level error occured
RuntimeException , logic or data validateion error that should have been found and fixed during development
Exception, run-time problems like a file that can't be found or a network problem

A program can catch exceptions by using a combination of the try, catch, and finally blocks.

The try block identifies a block of code in which an exception can occur.
The catch block identifies a block of code, known as an exception handler, that can handle a particular type of exception.
The finally block identifies a block of code that is guaranteed to execute, and is the right place to close files, recover resources, and otherwise clean up after the code enclosed in the try block.

Assert
This was added in Java 1.4, it is a simple way to check run-time conditions and throw exceptions when you are debugging code
It can be enabled or disabled at runtime, by default they are disabled, use the -ea switch from the command line to enable it. Since Java doesn't have a preprocessor this would be a way to do testing without having to modify the code

Input/Output
We looked at IO and the different IO classes to work with files, streams sockets etc etc

Here is a list of the I/O Streams

Byte Streams
handle I/O of raw binary data.

Character Streams
handle I/O of character data, automatically handling translation to and from the local character set.

Buffered Streams
optimize input and output by reducing the number of calls to the native API.

Scanning and Formatting
allows a program to read and write formatted text.

I/O from the Command Line
describes the Standard Streams and the Console object.

Data Streams
handle binary I/O of primitive data type and String values.

Object Streams
handle binary I/O of objects.

That is all for today

Original post blogged on LessThanDot.

Enterprise Developer

Windows Azure Training Kit April 2013 Released

Windows 8 for the Enterprise Event - Tuesday, April 16th

Windows Azure Training Kit available

Displaying .Net Build Warnings in TeamCity

Capturing the Build Warnings

Condensed Warning List in Build Log

Condensed Warning List in Archived Text File

Warning count in build status

Warning Count as a Custom Chart

Adding a Custom Build Warnings Tab

$count Build Warnings

Wrap-up

$count Build Warnings

Scala: The difference between val and var

Review of The Well-Grounded Java Developer

Installing Scala 2.10 on Eclipse Juno

Experimental features

Auto-Verifying Moqs

Java Training Day 5

Java Training Day 4