Redis in Action by Josiah L. Carlson

July 27th, 2015

redis_in_action
Redis in Action has at least 270 pages of content, about 4 times the Redis Cookbook. It was published June 28, 2013 – 2 years later than the Redis Cookbook, so it is well equipped with better content.

The Author
Dr. Josiah L Carlson is well known as an active and helpful contributor on the Redis mailing list.
He has given talks about real-world uses of Redis, including building a self-service ad network, prioritizing task queues, web spiders, a Twitter analytics platform, real-time search engines, and more.
Josiah has worked for Google and is now the VP Technology of OpenMail.

Intro to Redis

Redis is an open source, BSD licensed, advanced key-value cache and store. It is often referred to as a data structure server since keys can contain strings, hashes, lists, sets, sorted sets, bitmaps and hyperloglogs.

You can run atomic operations on these types, like appending to a string; incrementing the value in a hash; pushing an element to a list; computing set intersection, union and difference; or getting the member with highest ranking in a sorted set.

Chapters
Part 1 Getting started
1 Getting to know Redis
2 Anatomy of a Redis web application

Part 2 Core concepts
3 Commands in Redis
4 Keeping data safe and ensuring performance
5 Using Redis for application support
6 Application components in Redis
7 Search-based applications
8 Building a simple social network

3 Next steps
9 Reducing memory use
10 Scaling Redis
11 Scripting Redis with Lua

About The Book
As compared to the other Redis book that I reviewed earlier, this is definitely the better one.
While Part 1 chapters are meant as introduction, it has example for web application usage.
Part 2 Core Concepts are really the important chapters on how to use Redis, its data types, persistence options, replication and many more.
Part 3 of the book discusses about performance tuning such as reducing memory usage, scaling higher read and write as well as Lua scripting.

Conclusion
As a Redis reference book, I think Redis in Action does the job pretty well.
One thing that I think can be improved would be to add the various available options for Redis clients.
In fact, for a book published only 2 years ago, it would have helped with some revisit, especially now that Redis Cluster is available, I think an update to Part 3 of the book is warranted.

Books, Review, Software , ,





Redis Cookbook by Tiago Macedo, Fred Oliveira

July 20th, 2015

redis_cookbook  What is Redis?

Redis is an open source, BSD licensed, advanced key-value cache and store. It is often referred to as a data structure server since keys can contain strings, hashes, lists, sets, sorted sets, bitmaps and hyperloglogs.

So say it’s official website: http://redis.io/

I would call it an ‘in-memory/cache database” software.

While researching the available options for in-memory database, Redis seems to be the most popular, although not the newest.

This book has been published since August 6, 2011 and now in July 2015 there is no 2nd edition or any revisit of its 1st edition yet.

The Authors

Tiago Macedo is an Infrastructure Lead at 3scale Networks (http://www.3scale.net/) and has been working with Redis for more than a year. Macedo uses Redis as a high-performance storage engine for analytics data and used it as a temporary cache for contact syncing while working at Soocial (http://www.soocial.com/).

Fred Oliveira is an entrepreneur and designer. After living in Silicon Valley to work with Techcrunch and Edgeio, Fred started Webreakstuff (a design, development and strategy consultancy) to provide services to companies and individuals. Fred is co-founder of the Web 2.0 Workgroup with Michael Arrington of Techcrunch and Richard MacManus of Read/WriteWeb and a 2005 Google Summer of Code alumni. He is an early technology adopter and frequently blogs and speaks at conferences about technology, the role of design, and innovation.

 

Chapters

1. An Introduction to Redis
When to use Redis
Installing Redis
Using Redis Data Types
2. Clients
Using Redis from the Command Line
Using Redis from Python with redis-py
Using Redis from Ruby with redis-rb
Using Redis with Ruby on Rails
3. Leveraging Redis
Using Redis as a Key/Value Store
Inspecting Your Data
Implementing OAuth on Top of Redis
Using Redis’s Pub/Sub Functionality to Create a Chat System
Implementing an Inverted-Index Text Search with Redis
Analytics and Time-Based Data
Implementing a Job Queue with Redis
Extending Redis
4. Redis Administration and Maintenance
Configuring Persistence
Starting a Redis Slave
Handling a Dataset Larger Than Memory
Upgrading Redis
Backing up Redis
Sharding Redis

 

About The Book

Redis Cookbook is one of the earliest book for Redis and with only about 54 pages of content, one does not need to have much expectation from it.

In fact, Redis is popular because it is easy to use and as a caching tool, there simply isn’t much else it is supposed to do other than being able to cache fast, scales, and persistent. The official website does cover most of it with manuals and documentation.

However, if browsing the website still does not give you a better idea, then this book is essentially what you will need.

It explains in simple terms all the basic use-cases in four main chapters and it is able to lay down those use-cases which I think are most likely used.

There are now many Redis clients available but this book only covers the command line client, Python, Ruby and Ruby on Rails in summary mode. Of course it doesn’t make sense to cover all the clients in the book while they are being added, but this goes to show how dated this book is.

Conclusion

I think this book can pass as “another Redis book I have” if you need one simply as the most basic book of Redis in summary.

I cannot deny however, that the use cases are really beneficial to understand why such features are there instead of just knowing how to use it or getting it done.

Books, Review, Software , , ,



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 , , ,