Developer Summit 2009, day 2

A Technical Drilldown into “All Things M” by Brian Loesgen

M is a new modelling language that allows you to create domain specific languages or DSLs.

M today consists of three parts

• MSchema is a language for defining domain models.
• MGrammar is the language for defining DSLs.
• MGraph a data graph consumed by a runtime.

IntellliPad is an editor that understands MSchema and MGrammar. It allows you to define schemas and grammars and view them as graphs. The editor grammar is defined in itself. It seems to be very cool.

The specifications are open and it is possible to implement them for other platforms.

RESTful Enterprise Integration with Atom and AtomPub by Ian Robinson

Atom is the specification of the format.

AtomPub is an application protocol for editing Web resources using HTTP transfer of atom-formatted representation.

Ian demonstrated RESTBucks application that used an event-driven architecture that communicated via rest. Out of three different implementation options, point-to-point, bus and having the consumer pull the events the latter was chosen.

The product management system published the service by publishing an Atom feed. The client the pulls this feed to get the updates. The feed represents an event-stream. The feed contains a link to a previous feed-archive and the archive is immutable and therefore cacheable. An atom-entry represents an event.

Leonard Richardsson’s Web Service Maturity Heuristics

• Divide and conquer to spread complexity around with URIs.
• Do the same things in the same way to reduce complexity with uniform interface.
• Describe special behavior in a standrad way to make complexity learnable with hypermedia.

Taylorism och massproduktion by Marcus Ahnve

In the past man has been first; in the future systems must be first.

Taylor wrote a book about principles of how to get more work done. This was done by having management define the work to be done and then someone else has to do it.

Look out for:

• Division of labor
• Best Practice
• Standardized work
• Grouping of skills

Leaderful Moves for Managing Team Promises by Deborah Hartmann Preuss

What does your team really care about? Do you know? Do they?

Scandinavian Developers Conference Report

This is a short report from SDC. My comments are in italics.

Habits for Agility, Kent Beck

Kent changed his topic in the last minute. I would have liked to hear the promised talk on Responsive Design. Instead he talked about more general things.

Attitude

The desire to see reality as it is and to respond. What is reality? Whose reality?

Accountability, take responsibility for your work, no excuses.

Action

Effective teams are biased towards action. If you have a problem, research it, and know instead of think. Try instead of guess.

Time

Find focused time to work. The Pomodoro technique, do something for 25 minutes without interruptions. After finishing something, take some time to reflect before starting on the next task.

Connections

Analogies will help improving communication. Sales people are good at being accountable, because their salary depends on it. Customers are people whose daily lives are affected by your software. Good connections improve understanding between people.

Perspective

A perspective is about the same as an elevator pitch. What do you do? This is essential since this will help you when things get complicated.

Everything that is completely repeatable should be automated. The goal of development is to automate everything.

Support

Good teams find a way to get support, by meeting the needs of the people that can give you support.

Reflection

The cycle goes from action to reflection, ...

Ancient Philosophers and Blowhard Jamborees by Neil Ford

Neil had a nice presentation on the lore of software development.

Those who cannot learn from history are doomed to repeat it.

Books that are part of the lore of software. Smalltalk Best Practice Patterns, Mythical Man Month, The Pragmatic Programmer

Plato invented object orientation. The best way to solve problems is to think.

Aristotele, developed some important ideas like essential properties and accidental properties.

Galileo, didn’t believe anything he was told. Some things are counter-intuitive, anti-patterns.

Occam’s razor, given a set of solutions the simplest one is the best.

Fred Brooks, the second system is the most dangerous to build since you have all the knowledge of what went wrong with the first system it may be too difficult to get started with the second. KISS!

Cloud Computing, John Davies

John Davies talked about mostly about Amazons Web Services and showed how easy it is to set up an EC2 account. He also talked a bit about cloud computing in general. It seems to me that cloud computing is popular because it is easier to set up a new server in the cloud than it it to get the IT-department on the company to set it up. Something is wrong with this picture.

Google App Engine, for application written in Python. Amazon’s Web Services (AWS) include EC2, S3, Elastic Block Service, SimpleDB, and Simple Queue Service.

Advantages of cloud computing are reliability, security, scalability, volume testing, development with continuous integration and version control. It’s simple to setup new machines.

Setting up an EC2 account

• http://aws.amazon.com
• Create x509 certificate
• Download the EC2 API Tools
• Setup some environment variables
• Create a ssh key pair.
• AMI, Amazon Machine Instance
• Run instances, wait a minute, and log in.

Cool Tools

• Elastic Fox – firefox plugin
• ElasticPod – iPhone App

Functional, parallel, and asynchronous programming in F#, Don Syme

Don’s hands on approach to presentation is very nice. He didn’t show much that I hadn’t already seen though.

Why is Microsoft researching functional programming.

• Pleasure
• Economics
• Programmer Productivity

Started with an introduction of the F# language, nothing new. Then the interesting part started, the asynchronous, parallel coding.

let run x = Async.RunSynchronousy x

run(async {return 1+1})

run(ASync.Parallel [{return 2+2}, {return 3+3}])

Simple parallelism.

Outside In – Black Belt TDD/BDD, Niclas Nilsson

Niclas talked about why test first outside-in (or top-down) is better that inside-out. The reason is of course that you don’t create any code that is not necessary and that you know when you are done.

Moder IDEs will also support this style of coding since they can generate the missing method at will.

Time for Smalltalk again

March 24th, I’ll be giving another presentation on Smalltalk at the Scandinavian Developers Conference

The presentation will include:

• An introduction to Smalltalk.
• An overview of the language.
• A very basic enumeration of the persistence options in Smalltalk.
• Highlights from Seaside, templating in Smalltalk, and continuations.
• Finally I will wrap up with the reason the Smalltalk is still the best language when it comes to small and medium scale development. The living environment than enables refactoring and the complete availability of open classes that allows putting functionality in its proper place.

The presentation will be a mix between live demos and slides.

Report from Öredev day 1

Keynote with Ted Neward

The renaissance in development, according to Neward, is the renaissance of programming languages. The reason the renaissance is here is that the practitioners and the academics are, finally, working towards the same goal. Historically there has been downright hostility between them. This is because the academics and the practitioners are working towards different goals. The academics want to prove a concept while the practitioners wants to get work done. When the practitioners finally get what the academics have done the academics have left the project years ago.

Three forces work together to create the renaissance.

• Virtualization – virtual machines allow programmers to ignore the low-level details and to focus on the real problem. The same is true for language designers.
• Tools – IDEs, analyzers, debuggers, profilers, etc. are used by programmers and language designers use parser generators, AST generators, grammar debuggers, etc.
• Linguistics – Functional languages introduce new ideas, at least to the common programmer. Languages become more diverse to conceptualize different constructs, not everything is an object anymore. We have functions, aspects, meta-object protocols.

Technical challenges of the next generation are for example

• Concurrency
• Security
• Distribution and services
• User interface expression

There are more languages than ever and it is easier than ever to create your own language.

5(2) aspects you’ve never heard about by Alef Arendsen

Started with a quick introduction to AOP for logging. AOP is about the three Ws: Where?, When?, and What?.

Before, a business service, log a message.

• A pointcut is an expression for finding a number of joinpoints.
• A joinpoint is a place where you can inject an aspect.
• An advice is the code that is injected in the joinpoint.
• An aspect is the combination of a pointcut and an advice.
• Pointcuts should always be singular.

Aspect 1: Mixing Hibernate and JDBC usage

Hibernate uses transactional write-behind which will put the database and the cache out of sync. If I try to access the code via JDBC it will not get the correct data.

This can be solved with an aspect that flushes the cache to the database before a JDBC call is performed.

Before any JDBC operations flush the Hibernate session.

Aspect 2: Specific criteria should be applied based on orthogonal data.

I only want to get data from a specific location when performing a query.

Before a top level business service propagate location and after a top level business service delete location.

The advantage of this approach is again that it applies to both the Hibernate code and the JDBC code. It requires adding views to the database, but that would probably be a good idea anyway.

Dynamic Languages on .Net with J. Hartley

In five years we will look at compilation as the weakest form of unit testing.

Jim started out by saying that Ruby is not just simpler, but better :) Generics in C# is nice but it comes at a tremendous cost of obscuring the actual code.

IronPython supports Decorators to allow adding functionality through attributes. It will be supported in Visual Studio in 2009. An IronPython ScriptingEngine can be embedded into an application with a just a few lines of code.

What makes a programming language productive by Walter Bright

The D language is created by a diverse community of experts. It is a multi-paradigm language that supports c-style, OO, scripting, template metaprogramming, assembler, and functional programming. It is meant to replace C++.

The right way is the easy way. Work harder to do it the wrong way.

D supports simple template syntax. Header files are optional, type inference, foreach loops, reducing the source code with 30 percent compared to C++.

Diversity Challenges in Agile Teams by Aslam Khan

Writing software is cerebral but EQ overrides all IQ.

Leadership is taught to all, but followship is never taught.