You want to develop on Android and iOS, but rather not have to recreate your app or UI for each platform. This session shows you how to reuse up to 100% of your code and user interface to create native iOS and Android apps using Appmethod and C++. This isn’t your daddy’s C++ either; it has ARC, enhanced RTTI, visual designer, components and no pointer arithmetic (unless you are really into that).
Examples covering access to device sensors, local data storage and remote services. Also how to create a mobile app that extends the functionality of your desktop apps.
In this session we take a small, functional but tightly-coupled, software solution and improve its design using each of Robert C. Martin’s S.O.L.I.D. principles as follows:
- SRP: Single Responsibility Principle
- OCP: Open-Close Principle
- LSP: Liskov Substitution Principle
- ISP: Interface Segregation Principle
- DIP: Dependency Inversion Principle
Each principle is applied in sequence to the existing solution, making it possible for the attendee to observe the principle in relative isolation first while also evolving an understanding of how the principles all collaboratively reinforce each other when applied together.
Before each principle is applied and the solution is refactored to introduce it, the attendee is presented with one or two simple PowerPoint slides to introduce the concept and provide some abstract understanding of its goals and benefits to OO programming. The principle is then applied to the existing solution, demonstrating the practical application of the principle to working software.
At each step along the way, the existing solution (a simple console application) is re-executed, demonstrating that the overall behavior of the software solution has not been negatively impacted by the various refactorings.
By 2020, it is projected that there may be up to 200 billion (yes billion) Internet of Things and Embedded devices in the world. The opportunity for developers here is huge, and goes well beyond the tinkering that typically comes to mind. Microsoft has been involved in the Internet of Things space for decades, both with fully embedded versions of Windows and with products like the SPOT Watch and .NET Micro Framework. This year, IoT has become even more important, with an entire org now dedicated to this effort and with a renewed focus on enthusiasts, education, and businesses. In this talk, see our visiton for IoT, and through demos, learn how to use Visual Studio and Windows on tiny devices like Intel Quark, and Visual Studio and NETMF on devices like Netduino.
Moving dev and test to the cloud provides a quick and easy way to realize significant benefits of Microsoft Azure. Organizations naturally prioritize their budget to keep production systems up and running. This results in development and test being underfunded and not adequately equipped. It is further complicated by differing infrastructure objectives; dev and test wants to be agile while operations wants to be deliberate. There can even be challenges between development groups and QA regarding resource allocation. Microsoft Azure provides a simple solution; move dev and test operations to the cloud and gain agility and budget flexibility while removing resource contention among the different groups in an organization. This session will explain the benefits of moving dev and test to Azure and will demonstrate a number of ways you can leverage Azure to support your organization’s dev and test initiatives.
Imagine this: you’ve written a whole suite of tests that open up a browser and run through your entire web application, entering text and clicking on buttons just like a real user would. Even though they may take a while to write and to run, you’re confident that your browser-based test suite does a pretty good job of verifying the whole system. Quality is great and users are happy!
Then you need to make some UI change which breaks a dozen tests and you just don’t have time to fix them all… so you ignore them and promise yourself you’ll go back and fix them when you have the time (which you never do).
Then it happens AGAIN, resulting in a dozen more ignored tests.
THEN… Well, you get the point.
Not too long ago, experiences like that caused me to completely write off browser-based automated tests as flaky and a huge waste of time. That is, until I realized the main reason that my tests were so flaky is that I was writing them all wrong! In this presentation we’ll look at a subtle but powerful approach to browser-based testing that abstracts your test code from the details of your UI, making your tests easier to maintain by keeping you from having to rewrite them all the time, and bringing back the value of having browser-based automated tests again!
Michael Feathers defines “legacy code” as “code that has no unit tests”. Without unit tests your code is fragile, hard to change, and unreliable. Unit testing is the only way that you can be sure that your code does what it is supposed to do.
This talk discusses the basics of Unit Testing by defining terms, discussing what Unit Testing is and is not, and talking about the best techniques and practices for writing unit tests.
All the demos will be in Delphi code, but the principles all remain the same: There no longer is an excuse for not writing unit tests.
Knockout is a great library for observables and data-binding. It’s easy to get up and running quickly but if you’re not careful you can easily run into performance and maintainability issues.