Showing posts from September, 2014

Agile Retrospectives as Rock Band Show

Agile Retrospectives to me are like rock shows. So really depend of the moment and really happens this way for me. Like a rock concert depending of the moment you want to mosh or just be nice and relax or be happy and sing with the crowd. For me software development is like music, so there are moment where things are more calm, other moments are more like a rush and other moments are just transition between moments. So what are the moments? It`s really depend on how your team work and what you do, but lets say classical software development and see kinda of 3 big moments. This are not phases like you might think in RUP, but are not that different ideas, i like to think this trough the music so are kind of different rhythms or moments of a single song. So when you do the agile retrospective first of all you need to acknowledge with moment is the current one, it could be a combination of several things but it definitely will have a kinda of weather on the current moment the t

Inheritance + Mixins *with* another solution

In previous post i was talking about some alternatives to classical IoC/DI. I`m not here to argue whats bets or worst, the 2 approaches have advantages and cons. Most classical OO languages like JAVA and .NET tend to fix things at runtime. Java for instance all happens in runtime, spring context. JSF context, Hibernate/JPA context, reflection(memory), CGlib, proxies, etc.. In FP languages that are children of haskell like F# and Scala things tend to happen as much as possible close to the compiler and thats has good and bad things like everything in life. In java or .NET you dont have multiple inheritance like you do in C++. So another approach would be do inheritance and work with the ideas of Modules. Some people call this: Thin Cake Pattern, for me is just multiple inheritance with syntactic sugar. As long as you do it only for classes/traits and dont do it for values i think is ok and IMHO cleaner than the cake pattern.

Pure OO, Inversion of Control(IoC) + Dependency Injection(DI) and The Cake Pattern(FP): Whats really matters?

Software development continues to improve, once you add new languages, design concepts, paradigms(like functional programing) we start having new ways of doing things, so whats really matters? should i change somethings and embrace everything or should i change nothing? In this post i want cover something if you was java developer was the central idea around java development for years. Spring Framework dominate the fields for more than a decade. The real question is not if  you should be using XML or annotations(like Guice ). Either if you should go XML or java Annotations. Thats kind of old discussion, so basically what are the options now a days?

SOA has Roots in Agile and Functional Programming

SOA it`s about software architecture so its about an overall solutions for a business.  Thats what the 'A' stands for. Behind this we got Service Orientation as the main paradigm of doing some, its a way of thinking and it has principles like OOP, FP and Agile. SOA got popular around 2k years when business was moving to more complex functionality and more and more data. Them it came several buzzwords and vendor-like things, but soa was never about technology was always about principles and a specific way to think, see and build things, the service orientation. To capture this view a group of awesome people created the soa manifesto .

Streams, Map, Reduce and Filter on Java 8

For me this is one the most cool things java 8 got in sense of functional programming. This allow todo real functional programming with great benefit for legacy code, not only because we got modern constructs but also because you can reduce a lot the lines of code. The things i dont like in java 8 is that we still need some kinda of structure / definition thats a little bit heavy or not that natural like it is in scala or clojure but thats is something i guess we can live with it.  The other thing is the fact that immutability is not forced as much as we see in other languages the reasons are kinda of obvious it because java needs to respect they backward compatibility rules, whats great because my code can keep ruining into java 8 without any change or a i can embrace this "new" ideas and functional concepts and start taking benefits from it.

Whisky Engineers, please!

Whiskey is great booze. Besides that it has a property called maturity, so basically in this concept as old it get as better ir gets. So you have 8, 12, 18, 21 etc..  This is well recognized and people value that. Software development is more see as shit cheap Brazilian wine, you dont need better than 2 years old and actually if you let ir go older than that it got rotten and start getting worse instead of better. In Brazil Y career  are very popular and basically like in all parts of the globe everybody wants to be a manager.  Whats the problem with that, well for me none but its create some effects. In this life good things came with time, dedication and learning you dont great an awesome whisky in 2 years you need a least 12. Tell me how many developers you know that ave +15 years of experience in the field? It`s sad, as you start getting some level of maturity you are totally pushed by the system and need stop coding and spot being technically. Because people tend see cod

Functions, Method Reference and Predicates on Java 8

Back to some cool stuff around java 8 and functional programming ideas arriving on the JVM with java lets see some other cool stuff around Lambda. You can define your functions with a java.util.function.Function interface that allow you to store lambdas in "objects" and receive and pass it trough methods, so this allow you do high order functions. So lets go down to the code and see some samples around this. There are some samples i coded here with streams, i will cover with more details on other posts.

Consumers and Suppliers on Java 8

I worked with Scala since 2011. Its awesome, its clear to me java 8 copies several ideias from scala but thats fine, i think java 8 is not scala but is cool and its something we can take benefit as jvm users no matter if is coding on java or scala or groovy or jython or jruby. Java 8 finally bring some functional programming ideias into the JVM. Java 8 its hybrid part OO part functional. Java does functional programming using the constructs and the metaphor around the JVM so they sicked to the current design flow, what it make sense on the jvm design philosophy. (They copy some ideias from Scala, sure). Right the idea of this posts is talk a little bit on the @FunctionalInterface annotation and some Consumer and Supplier java.util.function.* functions, thats enable us do functional programming in java. Functional programming is java 8 required structure you cannot just start coding things like you do in clojrue or even scala. Some stuff on the JDK is already ported to @Function

Pick your Side (Slidecast)

SlideCast: Slides: Pick your side from Diego Pacheco

Innovation is the new Quality: Welcome to the (Entrepreneur) Gold Rush 2.0!

Everybody(maybe is not totally fair say that) wants money, thats true. Everybody needs money but people sometimes take different paths or different motivations. Tell me 5 or 10 years ago i didn't know someone from it that wanted to drop everything and open a bar? today the bar is A) A startup or B) Innovation inside a company. In Brazil people do startups in a very different way them guys in US tough.  So there is the insane rush going on everywhere this has being take the buzzword or hype to the next level. People are doing canvas with-out understanding jack-shit on system thinking, modeling or even sense of business, its a plague, like in the agile become scrum and canvas is like the new sticks notes now. IMHO i thins the business model generation is a good book and canvas its a fare tool, besides the fa-act(thanks to the mobile-first, maybe? maybe-not?) that everybody wants do a APP not have a business. There is huge difference to have a business and to build an APP.

Do not Code

What!? Yeah do not code. Coding is dangerous. When you code you create issues and issue cost money. The best thing you can do is A) Find a open source framework/library that does what you need. B) IF you don't have that try to adapt if make sense extend some framework/library or some parts of it, why? Open Source software has many advantages and its not only because is open but because people are fixing bugs for you fore free, most of people don't see this. No Matter how good your code is, you gonna have bugs, i`m not saying OSS does not have bugs, they have plenty of bugs but in fact the they a bunch of people around the world fixing that bugs for you. This post its beyond OSS...

4 Cool things on Functional Programming with Scala

Scala has many cool things around functional programming. I have mixed feelings with some of this features like case classes and patterns marchers, macros, generics, implicits, i question how good they are and if you really need them!? Besides there are some things that are practical and let you as a developer writes less code and code thats is more expressive, thats whats matter in the end of the day.  Some of this things might sound silly but if you consider that systems tend to be more and more complex now a days you will endup have todo more complex operations and less code you right, it would be better.