Archive

Archive for the ‘Open Source’ Category

Continuous Enterprise Development in Java by Andrew Lee Rubinger, Aslak Knutsen

May 14th, 2015

continuous_enterprise_development_java_cover
What is Continuous Enterprise Development?
The term Enterprise is used for the category of business software that are complex, scalable, distributed, component-based, and mission-critical.
Continuous software development is an umbrella term that describes several aspects of iterative software application development, including continuous integration, continuous delivery, continuous testing and continuous deployment – definition from http://searchsoftwarequality.techtarget.com/definition/Continuous-Software-Development.

  • Continuous integration refers specifically to the process of steadily adding new code commits to source code, a concept that has evolved over the years. Originally, a daily build was the standard for continuous integration. Today, the usual rule is for each team member to submit work as soon as it is finished and for a build to be conducted with each significant change. Usually, a certain baseline of automated unit and integration testing is performed to ensure that new code does not break the build. This way developers know as soon as they’re done if their code will meet minimum standards and they can fix problems while the code is still fresh in their minds. An important advantage of continuous integration is that it provides developers with immediate feedback and status updates for the software they are working on.
  • Continuous delivery builds on continuous integration and as with continuous integration, each code commit is automatically tested at the time it is added. In addition to the automated unit and integration testing, a continuous delivery system will include functional tests, regression tests and possibly other tests, such as pre-generated acceptance tests. After passing the automated tests, the code changes are sent to a staging environment for deployment.
  • Continuous testing adds manual testing to the continuous delivery model. With continuous testing, the test group will constantly test the most up-to-date version of available code. Continuous testing generally adds manual exploratory tests and user acceptance testing. This approach to testing is different from traditional testing because the software under test is expected to change over time, independent of a defined test-release schedule.
  • Continuous deployment adds more automation to the process to the software development process. After passing all the automated delivery tests, each code commit is deployed into production as soon as it is available. Because changes are delivered to end-users quickly and without human intervention, continuous deployment can be seen as risky. It requires a high degree of confidence both in the existing application infrastructure and in the development team. Continuous deployment is frequently seen in consumer-facing Web and mobile applications that frequently push updates to their customers as a part of the value that they bring.

The Authors
Andrew Lee Rubinger is an advocate for and speaker on open, testable enterprise Java development, member of the JBoss Core Development Team and Technical Lead of the ShrinkWrap project.
Aslak Knutsen is the project lead of Arquillian, is a Senior SoftwareEngineer at JBoss, by Red Hat. He’s involved in projects such as Arquillian, ShrinkWrap, Weld and Seam 3, and one of the founders of the JBoss Testing initiative.

About The Book
The are various tools explained and used as example for continuous development and testing in this book. Other than JBoss products such as JBoss Forge, JBoss EAP, other important tools such as Maven, Git, Arquillian, ShrinkWrap, OpenShift, Selenium, QUnit and AngularJS are used for the example project.
The book introduces its readers to the importance of proactive error handling and software quality that is the practice in recent software development.
It introduces JUnit and TestNG as test frameworks among the suggested tools as a test plaform for Java EE applications.
The book came along with a great example web application – GeekSeek that is publicly available at http://geekseek.continuousdev.org.
Chapters 5,6, and 7 provides some examples about testing the persistence and business layer while chapter 8 has some good information about REST services. It is crucial to know the stages of REST maturity level used in application, as most developers would misunderstood that their applications are RESTful just because the application is making calls with HTTP methods to some resource URIs.
The book then moved on to making the example application testable on the UI layer and guide readers to have the web app deployed automatically via Jenkins to Openshift.

Chapters
1. Continuity
2. Enabling Technologies
3. Scratch to Production
4. Requirements and the Example Application
5. Java Persistence and Relational Model
6. NoSQL : Data Grids and Graph Databases
7. Business Logic and the Services Layer
8. REST and Adressable Services
9. Security
10. The User Interface
11. Assembly and Deployment
12. Epilogue

Conclusion
This book is very important for modern day web and enterprise application developers to learn to make their application testable at all stages of development. The target reader of this book are experience developers and the examples and content are great to be used as a deployable project right away.
The content of this book can be sampled here, or access online at GitHub or purhased from Amazon via the following link:

Books, Java, Open Source, Review , , ,

Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development (3rd Edition)

May 31st, 2012

Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development is a software development book published by Prentice Hall in 2004. The current third edition is in its 14th print, dated January 2011.

Amazingly, most of the content inside this book is still very much applicable and relevant till this day in the world of software development. Of course, much of it has been updated to reflect the current software development scene, hence the ‘Third Edition’.

The author, Craig Larman is known throughout the worldwide software community as an expert and coach in OOA/D and design patterns, agile/iterative methods, an agile approach to the Unified Process (UP), and modeling with the UML. This is evident from the number of books written on Agile Development and this book, Applying UML and Patterns is among the most popular text worldwide for software development.

As Craig has turned out to be an ardent advocator of Agile, it is not surprising to see the book being updated with a lot of Agile related content.

Agile
For those who are not practicing Agile development yet, this book provides a high level understanding of the iterative development methodology and agile project management, probably helping you to switch from the conventional waterfall lifecycle development methodology. Using/being Agile has a lot of benefits especially in the software development world were changes is constant and changes very quickly.
Agile practitioners on the other hand will get to learn how to apply modelling in a Agile way.

UML
As UML is the core part of this book, so do expect heavy reading and visualizations of software systems in diagrams. You will get to learn how to model systems with examples targeted for a point of sales system (POS), and a monopoly game.
All UML diagrams such as package diagrams, use case diagrams, activity diagrams, state machine diagrams, system sequence diagrams, class diagrams, interaction diagrams are all well covered. The examples accompanying each diagram are also explained very well, allowing even a typical programmer to understand clearly what the author tries to convey.

Patterns
Patterns are used very commonly in Object-Oriented Analysis and Design. Software design patterns help Object-Oriented programming to solve common programming pitfalls and inefficiency so that a programming problem can be designed with the best possible solution that could scale, and be reused.
The Gang of Four, or GoF consists of four authors for the book Design Patterns: Elements of Reusable Object-Oriented Software, where design patterns first came into popularity.
While this book does not touch on all the design patterns written by the GoF, it provides a high level introduction on the GoF patterns.
Craig however, delves more into the GRASP concept. The different patterns and principles used in GRASP are: Controller, Creator, Indirection, Information Expert, High Cohesion, Low Coupling, Polymorphism, Protected Variations, and Pure Fabrication.


Oh yes, it’s THAT thick. Over 600 pages of text and diagrams weighing 3.6 pounds or 1.6 kilograms! Talk about heavy programming stuff (pun intended).

All in all, this book is a very comprehensive guide for starters in the world of programming who also wants to build better and proper software.
Not only that, this book also acts as a good companion to intermediate software developers or architects in designing software solutions to problems.

Books, Java, Open Source, Software , , , ,

Oracle vs Google – Android Court Case

April 17th, 2012

Oracle has made available the slides of the Oracle-Google case unfolding in a San Francisco courtroom also known as The World Series of IP.
I would probably call it the match of the Larry. Or Larries. 🙂
Larry Ellison of Oracle and Larry Page of Google.

In any argument, a party would only presents what is positive for them.
I’m interested to see how Google counter this, if possible with slides for the public as well.

Google, Open Source, Technology , , , , , , ,