Windows 8.1 Apps with XAML and C# Unleashed Book Review

As with Nathan's book WPF 4 Unleashed books, this book is a pure pleasure to read. It is in full color, the content is laid out in an easy to read style, the author's writing style makes it easy to read, and the content is all valuable. There is no fluff like you find in a lot of the books written today. Part I of the book starts out with an awesome chapter on the anatomy of a Windows store app and then has a great chapter introducing XAML. The book is broken down into a total of 7 parts. I have listed them below along with the chapters they contain. Part I: Getting Started Chapter 1. Hello, Real World! Chapter 2. Mastering XAML Part II: Building an App Chapter 3. Sizing, Positioning, and Transforming Elements Chapter 4. Layout Chapter 5. Interactivity Chapter 6. Handling Input: Touch, Mouse, Pen, and Keyboard Part III: Working with the App Model Chapter 7. App Lifecycle Chapter 8. Threading, Windows, and Pages Chapter 9. The Many Ways to Earn Money Part IV: Understanding Controls Chapter 10. Content Controls Chapter 11. Items Controls Chapter 12. Text Chapter 13. Images Chapter 14. Audio, Video, and Speech Chapter 15. Other Controls Part V: Leveraging the Richness of XAML Chapter 16. Vector Graphics Chapter 17. Animation Chapter 18. Styles, Templates, and Visual States Chapter 19. Data Binding Part VI: Exploiting Windows 8.1 Chapter 20. Working with Data Chapter 21. Supporting Charms Chapter 22. Leveraging Contracts Chapter 23. Reading from Sensors Chapter 24. Controlling Devices Chapter 25. Thinking Outside the App: Live Tiles, Notifications, and the Lock Screen Part VII: Advanced Features Chapter 26. Integrating DirectX Chapter 27. Custom Controls and Components Chapter 28. Layout with Custom Panels In Part II there are a lot of things that are specific to Windows 8 apps that developers are going to need to learn. The book does a great job of covering all of these. The first three chapters in this section cover interactivity, sizing, positioning, transforming elements, and layout, which now can be full-screen landscape, full-screen portrait, filled, and snapped. Chapter 6 is a very important chapter for developers that need to learn and understand touch. It covers touch, mouse, pen, and keyboard input. Developers need to understand the differences between the way pen digitizer works compared to a stylus that uses a capacitive touch screen. This chapter covers all the details that you need to know to get a firm grasp on the differences. This chapter also covers the basic Windows 8 gestures including tapped, right tapped, holding, and crossline. Part III is a new section which took chapter 7 of the last version of the book, broke it into 3 chapters, and enhanced the material. Chapter 7 is very important chapter in part three. This chapter covers the lifecycle of an application from launching to suspending to resuming to killing and terminating. It also covers how applications interact with the Windows store. Chapter 8 covers the threading model for Windows Store Apps, displaying multiple windows, and navigating between pages. Chapter 9 covers one of the topics developers are going to want to learn, which is how to support a free trial, and later how enable a full license of their application to be purchased. Part IV is all about controls, images, audio, and video. The controls covered include Button , HyperlinkButton , RepeatButton , ToggleButton , CheckBox , RadioButton , ToolTip , AppBar, Items Panels , ComboBox , ListBox , ListView , GridView , FlipView , SemanticZoom , TextBlock , RichTextBlock , TextBox , RichEditBox, MenuFlyout, Hub, and PasswordBox. The chapter on images not only covers the Image Element but includes coverage on encoding and decoding images. The chapter on audio and video include coverage of playback, capture, and transcoding. There is a ton of material covered in part four!!! Part V digs deep into XAML capabilities. Chapter 14 covers vector graphics which included shapes, geometries, and brushes. Chapter 15 covers animation which includes theme transitions and animations, custom animations, custom keyframe animations, easing functions, and manual animations. The title of Chapter 16 Styles, Templates, and Visual States some up exactly what that chapters about. Part VI covers a ton of information on how your application will integrate with the Windows 8 environment. It covers where you get your data from, how to integrate with charms, and how to implement extensions. Chapter 21 covers the accelerometer, qyrometer, inclinometer, compass, light sensor, orientation, location, and proximity. Chapter 25 covers Live Tiles, Toast Notifications, and the Lock Screen. As Windows 8 developers you are going to want to know how to use these features. The one topic I would have liked to have seen more on in Part VI is using SQLite. I mentioned this in my review of the previous version of this book. So far all the books that I have read on Windows 8 Apps tell you that it's available, but they don't explain how to use it. The apps I am working on are going to need a robust local data cache, and App Data and User Data are not going to be able to handle it. Part VII cover integrating with DirectX, building custom controls and components, and building custom panels for layout. Another thing I would like to see added to the book is a chapter on MVVM. The author says this, "You won’t find examples of patterns such as Model-View-ViewModel (MVVM) in this book. I am a fan of applying such patterns to code, but I don’t want to distract from the core lessons in each chapter. Whether you’re new to XAML or a long-time XAML developer, I hope you find this book to exhibit all these attributes." I know there is plenty of MVVM material available, but I would still like to see the author provide his view on how to use it in the context of the material presented in this book. There really is not a chapter in this book that should be skipped. Every chapter contains a wealth of valuable information for those looking to get into Windows 8 development. The author's writing style is very clean and easy to understand making the book an enjoyable read. The code samples are well organized, very usable and work as downloaded. I mention the work as download because lately I have been downloads some author's code samples and the time it takes to get them to work is more than they are worth. Over all this is an awesome book. It is a must have for any Windows 8.1 developer of any level.

Windows 8.1 Apps with XAML and C# Unleashed

Windows 8.1 Apps with XAML and C# Unleashed

iOS Programming: The Big Nerd Ranch Guide (4th Edition) Book Review

This book is the perfect place for an experienced developer to start with iOS programming. I say experienced developer because this book does a great job of showing you the basics of developing with iOS, but if you don't understand C and Objective-C, you are probably going to get lost. Maybe not, but I found myself saying, "I am glad I already know what that is" about quite a few topics that were used to explain the subject matter. If you don't know Objective-C, I would recommend starting with Objective-C Programming: The Big Nerd Ranch Guide (2nd Edition). This book does a great job of showing you what you need to know to get started with iOS. When you are done with it you should be able to easily move into programming iOS applications and learning more advanced topics along the way. To give you an idea of the high level topics the book cover, I have listed the chapters below. 1. A Simple iOS Application 2. Objective-C 3. Managing Memory with ARC 4. Views and the View Hierarchy 5. Views: Redrawing and UIScrollView 6. View Controllers 7. Delegation and Text Input 8. UITableView and UITableViewController 9. Editing UITableView 10. UINavigationController 11. Camera 12. Touch Events and UIResponder 13. UIGestureRecognizer and UIMenuController 14. Debugging Tools 15. Introduction to Auto Layout 16. Auto Layout: Programmatic Constraints 17. Autorotation, Popover Controllers, and Modal View Controllers 18. Saving, Loading, and Application States 19. Subclassing UITableViewCell 20. Dynamic Type 21. Web Services and UIWebView 22. UISplitViewController 23. Core Data 24. State Restoration 25. Localization 26. NSUserDefaults 27. Controlling Animations 28. UIStoryboard 29. Afterword With Objective-C Programming: The Big Nerd Ranch Guide (2nd Edition) the authors provided no code samples. Although they still push you very hard to type everything, they do provide code samples with this book. They are very well organized and usable. One thing I learned from Objective-C Programming: The Big Nerd Ranch Guide (2nd Edition) is that the authors are right, if you type the code instead of read the code, you will learn and retain a lot more of the topics covered. The reason for this is the way the authors use the samples throughout the book. It goes like this- add this ABC code, and then in the next example delete ABC code and add XYZ code, and then leave XY, but delete Z and add DEF code. You get the final result in the code samples, but going through what it took to get there is just as important. I have this fourth edition and the third edition. I never got around to reviewing the third edition, but wanted to make sure I reviewed this one because I feel it is an awesome asset to the experienced programmer looking to get into iOS programming. One thing I think most readers will notice right away is that the book does not use Storyboards until the last chapter of the book, and then the book puts the kibosh on them. I have used Storyboards in almost all my quick and dirty proof of concepts where I wanted simple navigation. In one of those I had to abandon them because of some complex navigation one sections of the application required. I wouldn't completely discount Storyboards and would use them if the applications functionality allowed for them. It is just like everything else, you need to understand the architecture and the functional needs of the app enough to make an informed decision. The diagrams in the book are awesome. They are UML-ish and really help by giving a visual representation of the topic at hand. The authors also use the right amount of screenshots. They do a good job of including them when they are needed, and they do not use them as filler. The book also makes a good reference. Topics are short and to the point. There isn't any filler in this book, so when you need to look something up you have a nice concise explanation at your fingertips. All in all, if you are looking to get into iOS, this is a great place to start. If you are an experienced iOS developer, it makes a nice reference for the features only used once in a blue moon.

iOS Programming: The Big Nerd Ranch Guide (4th Edition)

iOS Programming: The Big Nerd Ranch Guide (4th Edition)

Design Patterns in Java LiveLessons Review

I have spent the past few weeks watching this video series. I started watching it on the treadmill in the morning before work. I did that until I hit lesson 5. It is 4 hours and 20 minutes long. I started watching lesson 5 in front of the computer, not because I didn't want to walk for over four hours, but because I wanted to look at the code you can download with these lessons. In lesson 5 covers a ton of patterns. The thing I like most about the way the patterns are introduced is that they are introduced working with other patterns. The way patterns should be used, together. He uses lots of diagrams and walks through the tons of code making sure the patterns are thoroughly cover. The thing I liked most about the course was that the speaker is not a pattern zealot. He makes sure to tell you when you would not want to use patterns and why. He gives the advantages and disadvantages of each pattern. The downloadable code is very well organized and usable. It was really nice to just import the project, build it, and run it. No issues at all. I am not usually that lucky with Java samples. You do not need to know Java to watch this course. I do very very little in Java. I am in Objective-C or C# 90% of the time I am in code. I do have a lot of experience with patterns at all levels (code, integration, architectural, information management, enterprise, etc.). Although you can do without Java, I do recommend you have OOP under your belt. I also felt having the past experience with pattern really helped me keep up. If you don't have pattern experience, I think you may have to work a little harder to keep up. That is not a bad thing because the material covered is real worth the extra effort to get under your belt. The more you work at understanding the concepts the the speaker cover, the more embedded in your development thought process it will become. Below is a brief overview of each lesson. They are taken from the publisher's web site. Lesson 1: Experts in most domains perform quite differently than beginners. For example, professional athletes, musicians, and dancers move fluidly and effortlessly, without focusing on each individual movement. Likewise, when master software developers write code, they approach it differently than novices, drawing on years of design experience to help guide their solutions. When watching experts perform, it's often easy to forget how much effort they put into reaching these high levels of achievement. Continuous practice, repetition, and mentoring from other experts are crucial to their success. At the heart of all these activities is knowledge and mastery of patterns, which are reusable solutions to common problems that arise within particular contexts. In this lesson you learn to recognize the importance of design experience when becoming a master software developer. You also learn what patterns are and how they help codify design experience to improve software quality and developer productivity. In addition, you learn the common characteristics of patterns and pattern descriptions. Finally, you learn about the history of the Gang of Four book and its patterns, as well as learn about key types of relationships among patterns. Lesson 2: While it’s certainly possible to discuss patterns in the abstract, good design and programming practices are not best learned through generalities and platitudes. Instead, it’s more effective to see how significant programs can be made easier to write and read, easier to maintain and modify, and more efficient and robust via the application of time-proven software patterns. This lesson therefore presents an overview of an expression tree processing app that we use as a case study throughout the course. You learn about the goals of this case study, which provides a realistic–yet tractable–context in which to explore the why, the how, and the benefits and limitations of applying many Gang of Four design patterns to an application written in Java. Using the case study as a guide, you also learn how to recognize key structural and behavioral properties in a domain, as well as understand the case study's functional and non-functional requirements. All the pattern-oriented software presented in the case study is available in open-source form from the course website. You can see throughout the course that applying Gang of Four patterns in the case study not only improves the application’s modularity, extensibility, and quality but also enhances its portability so that it runs on a range of Java platforms, including Android and Eclipse. Lesson 3: Algorithmic decomposition is a historically popular software development method that structures software based on the actions performed by algorithms in a program. It decomposes general actions in an algorithm iteratively and recursively into more specific actions. The design components in an algorithmic decomposition typically correspond to processing steps in an execution sequence, which are usually implemented via functions or procedures. In this lesson you learn how to develop an algorithmic decomposition of the expression tree processing app case study. You also learn how to evaluate the benefits and limitations of algorithmic decomposition. This material provides a baseline for comparison with our pattern- and object-oriented expression tree processing app presented in subsequent lessons. Lesson 4: Object-oriented design is a method of planning a system of interacting objects to solve software problems. This design paradigm employs hierarchical data abstraction, where components are structured based on stable class/object roles and relationships, rather than functions corresponding to actions (as is the case with algorithmic decomposition). Moreover, object-oriented design associates actions with classes of objects in a manner that emphasizes high cohesion and low coupling. In many well-designed object-oriented programs, classes and objects are defined and associated in accordance with patterns and combined to form frameworks. In this lesson you learn how to develop an object-oriented design for the expression tree processing app case study. In addition, you learn how to evaluate the benefits and limitations of object-oriented design relative to the algorithmic decomposition approach presented in Lesson 3. Lesson 5: The book Design Patterns: Elements of Reusable Object-Oriented Software (the so-called “Gang of Four” book) presents 23 patterns that document recurring solutions to common problems that arise when developing software in particular contexts. In this lesson you learn how more than a dozen patterns from the Gang of Four book can be applied to the Java-based expression tree processing app case study to resolve key design problems and improve the apps modularity, extensibility, portability, and quality. This lesson forms the bulk of the course and covers the following patterns: • Composite, which treats individual objects and multiple, recursively-composed objects uniformly. • Bridge, which separates an abstraction from its implementation(s) so the two can vary independently. • Interpreter, which when given a language, defines a representation for its grammar. • Builder, which separates the construction of a complex object from its representation. • Iterator, which accesses elements of an aggregate without exposing its representation. • Strategy, which defines a family of algorithms, encapsulates each one, and makes them interchangeable. • Visitor, which centralizes operations on an object structure so that they can vary independently. • Command, which encapsulates the request for a service as an object. • Factory Method, which provides an interface for creating an object, but leaves the choice of the concrete type to a subclass. • State, which allows an object to alter its behavior when its internal state changes, making object appear to change its class. • Template Method, which provides a skeleton of an algorithm in a method, deferring some steps to subclasses. • Singleton, which ensures a class only has one instance and provides a global point of access. The lesson also touches on several other Gang of Four patterns, including Abstract Factory, Adaptor, Decorator, and Observer. Lesson 6: The pattern- and object-oriented version of the expression tree processing app case study presented in Lesson 5 provided many improvements compared with the algorithmic decomposition approach described in Lesson 3. For example, it's much more modular and extensible, its design matches the domain better, and it incurs less space overhead. The design of the expression tree process app also exhibits “high pattern density.” For instance, nearly all its classes play a role in one or more Gang of Four patterns. In addition, patterns help clarify the relationships of the many classes comprising the case study’s design. The same pattern-oriented design can be implemented readily in many popular object-oriented programming languages. For example, the Java and C++ solutions are nearly identical, modulo minor syntactic and semantic differences in these two languages. Although pattern- and object-oriented solutions are powerful, becoming a master software developer requires a balanced and nuanced understanding of the pros and cons of patterns. In this lesson, you learn how to evaluate both the benefits and limitations of patterns. I highly recommend this video series to anyone working in an object oriented language. Get the video series here. If you have no design pattern experience at all, below are a few of the best available on the topic.

Being Agile: Eleven Breakthrough Techniques to Keep You from "Waterfalling Backward" Book Review

There are teams out there attempting to introduce agile practices into their environments that do not go all in. No matter how hard they try, they just never get there. This book breaks down 11 of the biggest issues teams like that have. After an introduction to the book and the perspective the authors have of agile practices, the book has a full chapter for each of the issues the authors have identified. Introduction Chapter 1. Whole Teams Chapter 2. Active Stakeholder Interaction Chapter 3. Queuing Theory Chapter 4. No Multitasking Chapter 5. Eliminate Waste Chapter 6. Working Software Chapter 7. Deliver Value Chapter 8. Release Often Chapter 9. Stop the Line Chapter 10. Agile Leadership Chapter 11. Continuous Improvement Appendix Every chapter has an introduction and then is broken down into 5 parts- Principles, Practices, Metrics, Breakthrough, and Summary. The Principles section provides the theory, and the evidence for the practices that follow, for the topic at hand. The Metrics section provides suggestions on how you can measure how you are doing in the topic. The Breakthrough section gives recommendations on how to achieve a breakthrough in the troubled area. The summary provides a nice bullet point summary of the main points made throughout the chapter. Every chapter in the book provides great advice, but when I turned to the first page of Chapter 4 and saw the title No Multitasking staring me back in the face I actually chuckled. Not because the authors went off track, but because I have yet to be in an environment where the management didn't believe the exact opposite. Most of the management teams were happy with your performance when you hit the threshold of having just enough multitasking going on that you are spread too thin to be effective in any of your tasks. To them context switching is just a myth. It doesn't really exist. Chapter 6 has a section titled "Evolutionary Architecture and Emergent Design". Although there are a lot of books that miss the mark when describing these topics, I am glad these authors didn't. Unless a project is trivial, architecture cannot not be ignored, but the sad fact is, it is almost always overlooked. The problem is even though these books explain these topics correctly, if the readers don't have experience with architecture, it won't go any further than the explanations found in these books. If they do have experience with architecture, and doing architecture right, they will already be doing architecture this way. Architecture is an activity as well as an iteratively developed asset which is both code and documentation. The number one quality attribute in almost all projects should be modifiability. If correct modifiability scenarios and tactics are applied early in the project, your architecture should easily absorb change. The authors of the book say "Contrary to popular mythology, evolutionary architecture does start with an architectural model, just not a finished model. So, if you’ve heard that evolutionary architecture is nothing more than an architectural “wild-west show,” I ask you to set such thoughts aside and read on." Chapter 9. Stop the Line is a great chapter. Stopping the line means that you stop what you are doing and fix a problem by fixing the root cause of the problem so that the problem does not return. This concept is a hard sell no matter what the environment is. When there is a big show stopping issue, there is always a Band-Aid that is cheaper and faster than fixing the root of the problem, and when the business finds out they don't care anything about a root problem. Even if you know that over time the Band-Aid will cost them 5 times what fixing the root problem will, you better know how to communicate that in their language. This task takes usually takes an architect to actually pull it off. I have witnessed CIOs, project managers, and developers fail at this repeatedly. The CIOs are not technically savvy enough to explain the issue or its future affects, the project managers are usually of the same mindset and looking for a quick fix to keep dates from slipping, and the developers are not used to having to present technical topics in a way the business understands. Let's face it, there are way too many books, and way too much information available on agile these days. I'll be the first to admit, that every time I see an agile book coming out the first thing I think is how could they possibly still be milking agile. I also must admit, that many of the new books coming out on agile are now reflective of experience, and not based entirely on theory. That was what you used to find in the agile library, all theory and no experience. Architecture, lifecycle phases, documentation, and specialized skill sets for certain roles throughout the process have made their way back into the agile world on projects that are larger than a 3 to 5 person team can handle. Thank goodness any good agile book you pick up today will either include these topics as absolutely essential, or you can throw it in the garbage. I found the advice in this book to be dead on for the issues they discuss. The book is less than 300 pages, so it is a short read, full of practical and relevant advice, with absolutely no filler. I highly recommend this book to those in the throes of trying to introduce agile practices into their environment.

Being Agile: Eleven Breakthrough Techniques to Keep You from "Waterfalling Backward"

Being Agile: Eleven Breakthrough Techniques to Keep You from "Waterfalling Backward"