This came up as we were closing-out a recent stand-up meeting on an agile project, when the team were excited about some of the functional programming ideas we’d come up with. I love this place…my knowledge increases every day said one of the team, and this got me thinking about why Cake is such a great place to work – we live and learn and do great stuff – and we get paid for it too!

Cake is about to embark on a period of growth, with the opening of our second office, in Oxford. It’s a clear statement of ambition and confidence, and at the same time it’s a big stretch. We need to ensure the Cakeness which makes us special is preserved, especially the knowledge pool. Working for a small company means we have an intimacy about the team, especially individual and collective knowledge, rapport and camaraderie – it’s not like working for a large company, which is like getting on a train with all the other passengers. Are you doing fifty miles and hour or is the train going fifty miles an hour and you’re just standing still?

We’re knowledge and innovation business, operating in the software development market, and consequently everyone wants to make a difference and keep on top of their game. So what drives us in this hunger for knowledge?

You start craving for knowledge and do not leave any source unturned to acquire it. It may be making you and people around you wiser, it could be adding spiritual maturity to you or it could be to improve your capability and fulfilment in your current or future role at work. Whatever your motivation, the mental process of knowing, including aspects such as awareness, perception, reasoning, and judgment are all stimulating and interesting points for self-reflection.

What is it that drives people into the jungles of the unknown? For me it is the mind’s inner urge to seek more learning, developing points of view and perspectives. The all-absorbing urge for knowledge is one of the thinking person’s deepest needs, and for me knowledge is interesting in itself and is personal strength, the greatest strength of all. There is much effort in gaining knowledge by everyone of us as we all think that what knowledge we have is insufficient. By understanding ever more knowledge, testing it and experiencing the wisdom in it one can only ever love the thirst. It is knowledge that is truly satisfying to our spirit, it brings us life and ever more greater life. Of course, that depends on your point of view, I’ve heard some people say ‘Ignorance is paradise’, but for me that’s simply not true.

But is the widespread availability of technology generating such wisdom or even improving our learning? Research shows that students using Google and online information portals today are producing work no better than they were 20 years ago using printed sources. Despite amazing technical breakthroughs, these technologies haven’t added to human knowledge, rather making plagiarism rife and discouraging original thinking and ‘lazy’ research. Information on a plate to satisfy short-term hunger, rather than feeding a yearning for genuine knowledge, and while technology enthusiasts celebrate the destruction of old industries, we’re left with the banality of Google and Wikipedia.

Of course, e-books are great inventions of convenience, but just like iTunes and digital music downloads, the tactile experience of holding a book in your hands is lost just as the loss of album sleeve notes is no longer part of the experience. However, I realise that after spending my Christmas Amazon vouchers – on a combination of ‘real’ books and kindle e-books – that I’m a collector of books rather than a reader, but feel good about myself in that I have an accumulated stock of future reading and thus a pile of new knowledge to unearth from reading.

Once I’ve done this, I find the tactile experience of finishing a physical book and closing it for the last time produces a mellowness, a warm glow, an inner feeling of contentment and happiness. Ok, we have the web with various blogs and online community sources to reach out and get new knowledge, but there is something about reading a book, the physicality of having it in your hands, that stands out from digital media.

The most wonderful thing that reading offers is a peep into another world. When you pick up a book and lose yourself into it, its like you have transcended your present situation. This temporary escape from our routine life is of great significance when it comes to your mental well-being. We all have day-to-days tasks to take care of, and many a times we go to bed all tense and frustrated and sometimes just downright bored with life. This is when reading comes to our rescue and we should welcome it with open arms if we truly want to be happy and alive. Reading offers us a chance to see the world from someone else’s eyes, thus broadening our horizons and opening our minds to new possibilities. Reading is to the mind what exercise is to the body.

You emerge out of this trance-like situation, fully refreshed, with a clearer vision and rejuvenated spirit. So the next time you feel as if your mental batteries could do with a recharge, pick up a good book and immerse yourself into for a good hour or so. And mind you, this solution comes with a guarantee card.  Reading is a great imagination booster and it helps develop a sense of creativity in you. It will also help you develop better concentration which we need so bad at all times.

Are there many times in life where you probably find yourself gaining knowledge and coming to a place where everything is working well for you at the given moment because of your newfound awareness……but then it all fall apart again at the next moment?

Sometimes it just makes you wonder what the heck is going on. The reason is because you still haven’t possessed the rest of the awareness you need for it to happen. As you keep learning and growing, you will keep getting more and more pieces of the puzzle so that you are able to acquire better and better mastery in different areas of life for creating your desired reality. Your life will get better and better when you keep picking yourself up in those areas that you have fallen and walk on, and do some great stuff!

But back to Cake, and our knowledge pool, and the point about knowledge, fulfilment and personal progression at work. Think about the formula for the traditional deal at work, which goes something like this:

I work… to earn money… which I use… to consume stuff… which makes me happy.

I suggest that this deal is not a sufficient description of what work can and should be. Instead I put forward the following knowledge-based and future-focused deal, which we think makes Cake different:

I work… to gain productive experiences… to improve my knowledge…that is the basis… of my happiness.

But this begs the question – what exactly is a meaningful productive experience, and how do you know when your work is meaningful? So here are the 10 questions we asked ourselves to establish whether our work at Cake is meaningful, based around knowledge, fulfilment and all the stuff we’ve gone on about above:

• Do you use the majority of the knowledge you have on a daily basis?…because meaningful work provides an opportunity for you to keep your knowledge fresh by using it constantly.

• Do you feel intellectually stretched in your work?…because meaningful work both uses the knowledge you have and pushes the boundaries of what you can become.

• Are you able to learn something new at least once a week?…because meaningful work creates constant opportunity for learning.

• In your view are your colleagues at work knowledgeable and do you learn from them constantly?…because meaningful work is also about the colleagues who come with it, and your learning and development comes primarily through learning from others: ‘The Cake Tribe’.

• Are the tasks you do at work interesting and complex?…because at the heart of meaningful work are the day-to-day tasks that you do.

• Do you get lots of feedback about how you are doing?…because meaningful work enables you to grow, and feedback from others is a crucial part of this.

• Do you think that the work you do has a positive impact on the business?…because meaningful work enables you to make a clear link in your mind between the tasks you perform and the broader goals of the business.

• Do you think that the work you do has a positive impact on society?…because meaningful work is made up of tasks that you believe do good and, as a consequence, make you feel good about yourself.

• In your daily work, do you have the opportunity to reach out to develop networks with people very different from yourself?…because meaningful work creates opportunities for you to develop the ‘Big Ideas Crowd’ that is so crucial to developing your innovative and creative capacity.

• Does your work give you time to really develop deep regenerative relationships with people inside and outside of your organisation?…because meaningful work creates time and space for you to develop emotionally.

So where are you on meaningful work?

Score 8-10 Through your active choices, or sheer luck, you are working in a meaningful way. Cherish the opportunities this provides and don’t compromise in the future.

Score 5-7
Some aspects of your work are meaningful. Take a closer look at those you have said no to and search for the underlying patterns. Is it possible to focus on developing these areas?

Score 1-4
Your job lacks meaning – you already know that! The question is – what are you going to do about it?

So there you have it, an inside perspective of what we think about in Cake when we’re not building great software. Take a look at our blogs, get in touch and join one of our communities, come inside for a conversation where we can share knowledge and do some meaningful work together.

“My question is whether this is the most logical/efficient approach as per the reading list and updated topics you’ve given. My revised approach is to approach a little of everything: Haskell, Scala, Akka, AMQP, virtualization, et cetera. I wondered if you had any recommendations…”

Indeed I have.

What is functional programming

Functional programming languages help us reason about the outcome of a computation. As you might guess, the core element of functional language is a function; a function in a mathematical sense. A function that takes some input and maps it to some output; we might not be able to see inside a function, but we know that for the same x a function will always give the same y. Notice that this is very different from the concept of functions in C, Pascal, Java and others.

Functions

Let’s take what might seem like a detour through mathematics. In mathematics, when I write

f(x) = x * x,

I know that f(5) is 25 every time I “execute” the function. This gives us a convenient computational model: substitution. Imagine I add another function, g(x) = x + 1. If I now ask you to compute (f o g)(5). You will probably go about this by performing substitution:

• Compute g(5) by taking the “body” of g, substituting every x for 5, giving 5 + 1 = 6,
• Substitute g(5) in f(g(5)) with 6, giving f(6),
• Compute f(6) using the same substitution process, giving 36 ∎

But there’s another substitution: when computing f(g(x)), swap every x for g(x) in the body of f, giving (f o g)(x) = g(x) * g(x). I can even name the new function and arrive at h = (f o g), which–following the substitution steps–is h(x) = (x + 1) * (x + 1). Computing h(5) is (5 + 1) * (5 + 1), which is indeed 36 ∎ Good!

Non-functions

Recall that a function returns the same value for the same input, g(5) is 6, g(6) = 7; g(5) is never 7 or 5 (or any other value). Let’s think of a simple non-function that you are all familiar with: random. If I include random in my function g(x) = x + random, then g is no longer a function. Computing g(5) could return 44 now and 5534345 a moment later. This makes our model of computation much more difficult. Namely, how to compute f(g(5)) with the random element? The two approaches now give different results! I can either compute g(5), remember the value and then supply it to f or I can substitute g in f(x), giving h(x) = (x + random) * (x + random).

Let’s do the calculations: we can either compute g(x)first, giving

• Compute g(5) by taking the “body” of g, substituting every x for 5, giving 5 + random = 8,
• Substitute g(5) in f(g(5)) with 8, giving f(8),
• Compute f(8) using the same substitution process, giving 64 ∎

Or, I can compute a new function, h(x) = (x + random) * (x + random) and then compute h(5): the first term is (x + random), giving on this occasion 8. The second term, (x + random), gives 14. The result of h(5) is now 8 * 14, giving 112 ∎ Oops!

Back to code

After this brief excursion to mathematics, let’s turn our attention to programming, implementing the functions f and g in Java:

int f(int x) { return x * x; }
int g(int x) { return x + 1; }

Then the compiler cannot reason about the outcome of calling f(5). All that the Java (and C, Pascal, C#, …) compiler does is to transform the x * x into the appropriate machine instructions. The machine that executes these instructions is even dumber, it simply executes one instruction at a time, without remembering the instruction that came before it and without knowing the instruction that will follow.

The Java compiler does that mainly because it treats every method as a non-function. So, if I ask Java to compute f(g(5)), it will first compute g(5), and use the result in as the value of x in f(x). Partially because of this, Java can never allow me to write h = (f o g). First of all, the Java compiler cannot decide how to substitute g(x) and then Java does not have function as a data type. In other words, I cannot have:

int f ...
int g ...

int main(...) {
   Function h = f . g;

   h(5);
}

Functions as first-class values

So, this is the first thing functional languages bring: a function can now be a value; therefore I can assign a function to a variable and then take the variable that represents a function and apply it to some arguments. The concrete syntax differs language by language, but the concept is the same. A function is a value.

Non-pure functions

There are differences between the functional languages in the way that they enforce the function-ness. Scala, for example, does not enforce that a function is a function in the mathematical sense. Therefore, in Scala, I can write val f = (x: Int) => x * x and Scala will create a variable f and set it to be the function that takes an Int and returns a Int. The function f just so happens to be a pure function–a function in the mathematical sense, whose result depends only on its input. In Scala, I can also create function g that includes the randomness: val g = (x: Int) => x + (math.random * 1000).asInstanceOf[Int]. The function g takes an Int and returns an Int. Recall though from the previous paragraph that g is not a function in the mathematical sense! This drives how f(g(5)) will be computed: Scala will first compute g(5) and then use the computed value as the parameter of the function f. Most of the programmers don’t find this confusing or counter-intuitive, but it is not “right”. It restricts what I can do with the function variables and it fixes the flow of the program.

Pure functions and pure functional languages

Now, a pure function is our familiar f, whose result depends only on the value of its argument. Function g is not pure, because its result depends on something other than its argument. Now, there are functional programming languages that enforce that the functions are pure functions. Take Haskell, where the result of a function must depend only on its arguments. In Haskell, I cannot have the function g. So let’s change the function g back to its trivial form g(x) = x + 1 and write:

f :: Int -> Int
f x = x * x

g :: Int -> Int
g x = x + 1

I can now ask Haskell to compute f(g 5). It will say 36. But it will compute 36 completely differently. It will start by computing f x, where x acts like a promise to give the value when needed. When evaluating f, Haskell will delay computing the value of x until it needs it. (As it happens, in our function f, we need it immediately, but the pattern remains.) So, in the body of f, when Haskell needs x, it will evaluate g 5. This means Haskell actually computes (g 5) * (g 5). Obviously, g 5 gives 6, so the result of computing f(g(5)) is 36. Just like the Java or Scala code, but the difference is the way in which Haskell arrived at the result.

Now, because in Haskell (and other pure functional languages) functions are functions in the mathematical sense, I can easily create compound functions. The particular syntax in Haskell is f . g. This returns a new function whose body we’ve already seen. I can therefore have code:

h = f . g

Computing h(5) indeed returns 36.

Higher-order functions

Because functions (whether pure or not) are first-class values, there’s nothing stopping me from accepting functions as parameters of other functions. I can also create functions that return other functions. When a function takes another function as its parameter or when it returns a function, we call it higher-order function. Most of you will have heard of the map-and-reduce algorithm. Let’s focus on the map part for now. We take some sequence of things and we wish to do something to each thing in the sequence. We could write specialised map-like functions that perform operations such as “double every element”, “add 5 to every element”, and many more. We could have

double :: [Int] -> [Int]
double [] = []
double (x:xs) = x * x : double xs

addFive :: [Int] -> [Int]
addFive [] = []
addFive (x:xs) = x + 5 : addFive xs

In this case, we have two functions: the double and addFive which take list of numbers and return a list of numbers that have been doubled or have 5 added to them, respectively. But look! Both functions are nearly the same, except that the double function contains code x * x and the addFive function contains x + 5. It would be better if we could somehow inject code to be applied to every element. Remember that functions are first-class values, which we can use as arguments of functions! Let’s get rid of the double and addFive functions and replace them with a higher-order function map:

def map(as: List[Int])(f: Int => Int): List[Int] =
  as match {
    case Nil  => Nil
    case h::t => f(h) :: map(t)(f)
  }

This code is in Scala (thanks to Tony Morris for the improvement!); I can write similar code in Haskell:

map' :: [Int] -> (Int -> Int) -> [Int]
map' [] _ = []
map' (a:as) f = f a : map' as f

In both cases, I have function map that takes a function that takes a sequence of values of Ints and a function that takes individual Int and returns a new Int. Now I can compute the value of map(List(1, 2, 3))(_ + 1) in Scala (or map' [1, 2, 3] (+1) in Haskell) and get the same result, namely List(2, 3, 4).

Let’s complete the introduction by looking at functions that return functions. Such a function is a kind of factory of functions, say depending on the value of its argument. If the argument is 1 then the function should return a function that adds one; if the argument is 2 then the function should return a function that adds two, and so on. For example:

def mkf(x: Int) = x match {
  case 1 => {x: Int => x + 1}
  case 2 => {x: Int => x + 2}
  case 3 => {x: Int => x * x}
}

This is the code in Scala, we can have the same thing in Haskell’s syntax:

mkf :: Int -> (Int -> Int)
mkf x = case x of
         1 -> (\x -> x + 1)
         2 -> (\x -> x + 2)
         3 -> (\x -> x * x)

Now, let’s combine everything together. Let’s use the map function together with the mkf function to create a truly Frankensteinian monster:

map' [1, 2, 3] (mkf 1)

This Haskell gem will poo out [2,3,4]. It applies the function returned by computing mkf 1 to every element in the source sequence [1,2,3].

What’s next?

In the next instalment, we will explore type systems. Type systems are not specific to functional systems, but our favourite functional languages, Scala and Haskell are both functional and type safe languages.

As a motivation, doesn’t it bother you that the map function can apply arbitrary function to every element, but we require the elements to be Ints. What if I needed to map Strings? Or Customers? In the next post, you will learn about types; you will understand what we mean when we write:

map' :: [a] -> (a -> b) -> [b]

or

def map[A, B](as: List[A])(f: A => B): List[B]

Summary

In this introduction to functional programming, we found out what the mathematicians call a function. We then looked at how programming languages model the mathematical concept. We discovered that all languages allow us to compute results. Some languages simply spit out instructions that just so happen to arrive at the result. In those non-functional languages, a function is simply a name for a block of code that does something. Functional languages understand the notion of a function, therefore a function is no longer just a block of code, it can be a value. Because a function is a value, it can be passed around and even returned from other functions. Some functional languages go a step further and enforce the pureness of a function. Those language do a lot more reasoning of the control flow in the program.

Introduction

• What is Roo, what does it solve and why do we need it?
  • Roo is a code generator
  • The generated code follows contemporary Java/Spring style
  • It is easy to modify / add to the generated code
  • Roo can re-synchronise with the modified code
  • It is easy to remove Roo
• What Roo isn’t?
  • Not a multi-module, general purpose tool
  • Not a one-way code generator

[10:00]

Hello, World

• Show Hello, World Roo application (generate & run)
• Go through the commands we issue (project, persistence, entity, controller)
• Explore the generated source code (the directories, Maven dependencies)
• Building Roo applications
• The apps don’t build using javac? WTF?

[10:40]

Spring Framework Primer

• What is Spring?
• What does it solve?
• Its main components

[12:30]

Food!

AOP Primer

• Why do we need AOP when we have OOP?
• Cross-cutting concerns
• Pointcuts, Advices, JoinPoints and Aspects
• Dynamic weaving (proxies, subclasses)
• Static weaving (load and compile-time)

[14:30]

Architecting Hello, World

• Roo is not just one-way generator
  • It is very difficult to separate out custom code from the generated one
  • Roo splits the generated code from the custom code
  • It uses IDT aspects to simulate .NET’s partial classes
  • Roo can re-examine our code and keep its model of the application up to date
• Domain objects have persistence methods (just like RoR and Grails)
• Domain objects are the core of the application
• Controllers use the domain (and the persistence) to manipulate the data
• Maven maintains the dependencies and configures the build process (ajc)

[16:00]

Extending Hello, World

• Add a service
• Add a handler method to the controller
• Use & see DI

[17:00]

Sweet, sweet sleep

More AOP

• AspectJ syntax
• Mixins
• Compile-time static weaving using the ajc compiler

[10:00]

Exploring different fields

• See strings, integers, booleans, dates & friends
• Declarative validation, custom validation rules

[11:30]

Associations

• Have a Blog and Post relationship
• Explore the details of different associations (many-to-one, many-to-many)

[13:00]

Food!

Exploring the web tier

• Improve the standard data scaffolding
• Structure of the generated pages, tiles
• Explore the style sheets, JavaScript and AJAX
• Roo and REST

[14:30]

Roo and the team

• What if you have more people working on the same Roo application
• How to share the Roo code, how to keep the generated code and the Roo sources synchronized
• Automated builds and tests

[16:00]

Q&A

• Interesting goodies for exceptional attendees
• Questions
• Pet projects

[17:00]

Get booking!

With the new version of the module, the first attendees are going to explore how deep the rabbit hole really goes! I talk about the various types of memory in a computer, then show how the operating system presents this memory to user processes (see Figure 1).

I then take a plunge into memory management in user processes. I start with the simplest memory management strategy: reference counting. Even though it is not applicable to Java and [safe] .NET code, it is still widely used strategy.
Once the reference counting is out of the way, I look at true managed environments. I explore the operation as well as management of the managed heap. The example slide in Figure 2 shows what the JVM does to allocate an object on the heap.

Next, I show what happens when the JVM frees some objects and I don’t skim on the details. You will learn about the defragmentation strategies and you will understand exactly why generational heaps are an excellent idea (see Figure 3).

But that’s not all. Lifecycle of Java objects is not simply active -> freed; Java objects can be finalizable, in which case, the garbage objects fester around until the finalizer thread deals with them. (Does ‘festering’ sufficiently convey the fact that finalizers are generally not a good idea? Yes? Good!)

Obviously, I did not remove the content on the reference types and their operation and typical usage. So, after taking this module, you will have a good understanding of what the OS and the JVM does to manage memory. You will also be able to use this knowledge to make your Java programs perform much better by configuring the garbage collector and using the appropriate references in your code.

A word of warning, though: this module is complex and you may be wishing that you did not sleep through those hardware architecture and discrete mathematics lectures!

So, if you’re experienced Java developer and want to learn about the Spring Framework, book the course and, in four days’ time, you will be able to create three-tiered Spring 3 web application.

The course outline is

Anatomy of Spring application

Why Spring and how does Spring fit into your application.

What does Spring do?

Dependency injection and AOP; we explain the dependency injection concepts, bean lifecycle, we sprinkle it with the Spring annotations, including SPEL! We then press on with aspect-oriented programming, showing AOP support in the Spring Framework.

The workers

Understand how Spring fits into the data access and middle tiers. We go from JDBC to Hibernate and sprinkle it with a bit of Spring transaction management.

The web

Overview of modern web applications; understanding how Spring’s MVC support makes web programming really easy and efficient. We wrap up with REST support!

The goodies

If there is still some time left at the end of the course, we can include large-scale data processing (using JDBC batching and job monitoring); after which, we show that Spring Batch 2.0 offers the solution out of the box!