This week's Wednesday Evening Training: Quantum Computers are coming!

Could you imagine? You solve problems with a speed of light. What a classical computer takes 1000 years to complete, you can achieve in just 100 milliseconds. You can find a needle in a haystack in 1 nanosecond. You can simulate molecule structures as if they are real. You can send data with the speed of light. That is now possible with Quantum computing.

So what are Quantum computers?

A very very very short introduction on Quantum computers As progress on processing speed and miniaturization continues, we stuble on the phycical limits of modern binary digital electronic computers based on transistors. Using quantum physics, however, we can increase processing speed drastically. In digital computing data is encoded into binary digits (bits), each of which is always in one of two definite states (0 or 1). A quantum computer works with particles that can be in superposition. Quantum computers use Quantum Bits or Qubits, which can take on the value 0, or 1, or both simultaneously. This drastically speeds up processing. This, however, also poses other challenges.

For quantum computers to work, you'll need them to work in a supercooled condition. Also, calculation results may not be accurate. You'll need software to determine whether the result is correct.

Are there any Quantum Computers available yet? 

Yes... there are... but they are experimental and you can't yet buy them in the store nor can you online. IBM, Microsoft, Google, Apple and other companies are already building devices (see the resources below). At this moment, you can use online simulators to experiment with. Also see the resources below for a few examples.

What can we use Quantum computers for? 

In short: Quantum computers are not suitable for running all programs. But for very intensive applications such as simulations, processing huge amounts of data and artificial intelligence they can be very useful. Future will tell! Well, that's all in a nutshell. You'll find some excellent and comprehensible explanations in the resources mentioned below as well.

Back to this evening's training...

This Wednesday Evening Training, we got a nice introduction on Quantum Computers and Microsoft's Quantum Software Development Kit. One of our Quantum Computer experts, Ilyas Sener, explained us the physics, gave us a nice demo of a Quantum computer simulation and did a code walkthrough of a Q# software solution (using Microsoft's Quantum Software Development Kit and Visual Studio 2017). The Q# Programming Language Q# (Q-sharp) is a domain-specific programming language used for expressing quantum algorithms. It is to be used for writing sub-programs that execute on an adjunct quantum processor, under the control of a classical host program and computer.

Interesting stuff, but obviously we need more Wednesday Evening Trainings to understand the concepts and devise practical applications. And that's what the Wednesday Evening Trainings are all about: playing, learning & sharing knowledge!

We also welcomed our colleague from UWV, Robert Mast, one of their top .NET software engineers. Surely we'll be seeing you next session on Quantum Computers Robert!

Further reading

Do you want to read more on the topics in this post? Here are some links…

On the basics of quantum physics:
Quantum Computing Expert Explains One Concept in 5 Levels of Difficulty (an excellent way to start!): https://www.youtube.com/watch?v=OWJCfOvochA
Qubit (the basic unit of quantum information): https://en.wikipedia.org/wiki/Qubit
Quantum information (information that is held in the state of a quantum system): https://en.wikipedia.org/wiki/Quantum_information
Quantum system: https://en.wikipedia.org/wiki/Quantum_system
Quantum mechanics: https://en.wikipedia.org/wiki/Quantum_mechanics
Quantum Computing Primer: https://www.dwavesys.com/tutorials/background-reading-series/quantum-computing-primer
Quantum Computing basics: What is Quantum Computing?: https://www.microsoft.com/en-us/quantum/what-is-quantum-computing
Quantum Computing Technology: https://www.microsoft.com/en-us/quantum/technology

On quantum computer hardware:
IBM Q initiative to build commercially available universal quantum computers: https://www.research.ibm.com/ibm-q
Introduction to the D-Wave Quantum Hardware: https://www.dwavesys.com/tutorials/background-reading-series/introduction-d-wave-quantum-hardware
Software Architecture & environment: https://www.dwavesys.com/software

On quantum computer simulators:
IBM: https://quantumexperience.ng.bluemix.net/qx/editor
The QX Simulator: http://quantum-studio.net
Ready-to-use Linux Ubuntu Virtual Machine with QX installed: http://quantum-studio.net/#download_vm
Quantum Computing Playground: http://www.quantumplayground.net
QCEngine - active QC simulator: http://machinelevel.com/qc/
List of Quantum computer simulators: https://quantiki.org/wiki/list-qc-simulators
Another list of Quantum computer simulators: http://www.vcpc.univie.ac.at/~ian/hotlist/qc/simulation.shtml
Quantum computer simulator: https://qcsimulator.github.io/

On quantum computer software:
Microsoft Quantum Development Kit: https://www.microsoft.com/en-us/quantum/development-kit and https://docs.microsoft.com/en-us/quantum/?view=qsharp-preview
The Q# Programming Language: https://docs.microsoft.com/en-us/quantum/quantum-qr-intro?view=qsharp-preview
Download Quantum Studio: http://quantum-studio.net/#download_qs

Other resources:
Microsoft's Quantum Computing portal: https://www.microsoft.com/en-us/quantum
Microsoft's Quantum Computing, technologies (Physics, Materials, Devices, Control, Runtime): https://www.microsoft.com/en-us/quantum/technology
IBM Q Experience! Guides, demo's etc.: https://quantumexperience.ng.bluemix.net/qx/experience
Microsoft Quantum: https://www.microsoft.com/en-us/quantum
Microsoft Research on Quantum Computing: https://www.microsoft.com/en-us/research/lab/quantum/
Hello Quantum - Explore the building blocks of quantum mechanics through puzzles: http://helloquantum.mybluemix.net

Past Wednesday Evening Trainings

You 'll find post of previous sessions here: https://www.linkedin.com/search/results/content/?keywords=%23wednesdayeveningtraining

Next week 's Wednesday Evening Training

In next week's Wednesday Evening Training, we’ll give a 100-level introduction to Specflow, the Cucumber counterpart on the .NET plaform. We’ll show how you can use natural language to make unambiguous functional specification and at the same time generate unit tests to test your code against it.

#wednesdayeveningtraining #capgemini #lifeatcapgemini #quantumcomputing #qsharp

This week's Wednesday Evening Training: How to become a hacker! Introduction to (a bit of) security & hands-on hacking

This week's Wedneday Evening Training: How to become a hacker! Introduction to security & handson hacking

Have you ever thought of becoming a hacker? Or to find out how hackers manage to break into systems and/or web applications? This evening we got an excellent opportunity to experience this. One of our security experts, Vincenzo Corona, gave us a workshop to learn some hacking foundations and become familiar with some security best-practices.

So why hacking?

Security of information systems has always been an important topic. In the last decade, however, it even got more important. Since we seem to connect about anything to the internet (the web infrastructure is expanding rapidly) there are much more opportunities for hackers to take advantage of. Moreover: we get increasingly dependent to the internet in our daily life. So the business case for hackers is getting better every day. The more reason to give increasingly more attention to security.

And what better way for architects, sysops and software engineers is there than to learn to think like a hacker?

That is just what we did in this evening's training...

The best way to learn  is to get your hands dirty (figuratively speaking then). We built our own hacking lab using virtual machines and got our hands dirty with some of the most used hacking tools. Step by step we learned how to analyze the vulnerabilities of a target machine, to find and apply various hacking tools and methods and finally seizing complete control over the machine (root control). And this is exactly the way hackers work! It is amazing how much information you can get from a running machine! Even tiny bits of information can give you clues on weak points.
During the training we got plenty of opportunity to ask all kinds of questions on the operating system, working of webserver platforms and networks.

We are very enthusiastic on the way this workshop went. We wil definitely organize additional workshops in which we will explore more advances hacking scenario's. There are plenty of idea's for that, e.g. hacking an IoT infrastructure (in other Wednesday Evening Trainings we are already experimenting a lot with devices like the Raspberry Pi, Arduino and WittyCloud). We will also be paying attention to the countermeasures, both on infra / configuration and software engineering. There are many measures you can take to secure platforms and applications (safe and secure programming). It is a continuous battle, and that is why it is all the more important to keep up.

Thanks Vincenzo, for sharing your knowledge with us! And we look forward to the next sessions!

Resources

No, I'm not going to share links to hacking tools :)

Instead, I'll give you a link to the OWASP site: https://www.owasp.org
OWASP is an open community dedicated to enabling organizations to conceive, develop, acquire, operate, and maintain applications that can be trusted. All of the OWASP tools, documents, forums, and chapters are free and open to anyone interested in improving application security. We advocate approaching application security as a people, process, and technology problem because the most effective approaches to application security include improvements in all of these areas.
What you will find on their site is, among many other topics, are:

• Common types of application security attacks
• Guides, e.g. OWASP Guide to Building Secure Web Applications and Web Services, a Testing Guide
• Articles specifically about performing security penetration testing on web applications and web services

A site well worth to visit!

To get started, you'll also need a virtual machine. You can download one at https://www.virtualbox.org/.
VirtualBox is a powerful x86 and AMD64/Intel64 virtualization product for enterprise as well as home use. Not only is VirtualBox an extremely feature rich, high performance product for enterprise customers, it is also the only professional solution that is freely available as Open Source Software under the terms of the GNU General Public License (GPL) version 2. See "About VirtualBox" for an introduction.

Past Wednesday Evening Trainings

You'll find post of previous sessions here: https://www.linkedin.com/search/results/content/?keywords=%23wednesdayeveningtraining

If you wonder what happened with last week's Wednesday Evening Training: it just went on. In our CoZone our Wednesday Evening Training community had a "klusavond" on various topics. I, however, had a workshop abroad in the German Harz on gastronomy.

Next week's Wednesday Evening Training

Next Wednesday Evening Training, we'll have an introduction to Quantum computing and we'll experiment with the Microsoft Quantum Software Development Kit (Q language). Can you imagine? Solving problems with a speed of light?


#wednesdayeveningtraining #capgemini #werkenbijcapgemini #lifeatcapgemini #security #hacking

This week's Wednesday Evening Training: Microservices architecture and implementation in Java

A bit of architecture and a lot of code this week's Wednesday Evening Training. Together with Bart van Beek, one of our expert Java software engineers, I gave explanation on the architecture, design and engineering of a Microservices architecture.

So what is this "Microservices" architecture?

Let me give you a very, very, very short introduction. See the links in the bottom of this article for further reading & coding.

Since the creation of the first applications, we've continously been attempting to divide an application in manageable parts, so that we could design, develop, deploy and manage applications more effectively and efficiently. This is crucial because solutions nowadays more resembles a continuously changing eco system, rather than a stable and easily manageable one-piece software. Web services have made it possible to connect full applications over the internet in a standardized way, Microservices take this a step further. Microservices are deployed as a light weight, but fully functional applications with very limited functionality. Connected, they form fully functional capabilities (ready to use functionality and data) of which the parts can be changed, deploy and managed independently of each other. This enables continuously changing and deploying sofware parts by independend teams, in different technologies (e.g. Java, .NET) and scaling more easily by deploying the parts on different locations. Using virtual infrastructure and containers (e.g. Docker) you will be able to scale in and out very fast so that you can tune your software infrastructure neatly to what you need at a particular moment.

This drastic increase in flexibility comes with it's price: you will need to put more effort in implementing functionality like communication, coordination, orchestration, monitoring and exception handling that is normally handled in application and integration platforms. Also, engineers need also to be proficient with infrastructure and business processes, instead of just one programming language and related tools.

Therefore, it is increasingly important to follow patterns (standardized solutions). Luckily, there are a lot of patterns available. See the links in the bottom of this article for some of the resources on patterns.

Back to this evening's training...

After my introduction on Microservices architectures and related patterns, Bart gave us a demo and code walkthrough of a Java based Microservices implementation. We could experiment with the example implementation he provided and learned a lot of this. On the internet, we also found a reference implementation of a (Microsoft) Azure reference implementation. In a follow up we'll do a walkthrough of this implementaion as well, and also create a prototype solution in which we'll implement a Microservices solution using both Java and Microsoft technologies. To be continued...

One of the nice things of the Wednesday Evening Training is that we can decide on the spot which technology to discuss. So an evening that is originally focussed on a particular technology can suddenly be enriched with a completely different topic. One of our colleagues, Quincy Jacobs, had dived into OpenGL. OpenGL is closely related to BabylonJS which can be used combined with Unity3D, on which we already had some workshops. On the spot, we decided to plan an wednesday evening combining these topics, combining explanation on the underlying (3d) concepts and experimenting combining the technologies. Also to be continued...

Further reading

Do you want to read more on the topics in this post? Here are some links...

Introductions:
Microservices: https://en.wikipedia.org/wiki/Microservices
Service Oriented architecture: https://en.wikipedia.org/wiki/Service-oriented_architecture
Microservices vs SOA: https://www.bmc.com/blogs/microservices-vs-soa-whats-difference/
Microservices, a definition of this new architectural term: https://martinfowler.com/articles/microservices.html
Why a microservices approach to building applications? (giving an approach to designing and implementation) https://docs.microsoft.com/en-us/azure/service-fabric/service-fabric-overview-microservices
Designing, building, and operating microservices on Azure: https://docs.microsoft.com/en-us/azure/architecture/microservices/

Patterns:
Microservice patterns (explanation and patterns): http://www.microservicepatterns.org/
Cloud patterns (explanation and patterns): http://cloudpatterns.org/

Lots of info on patterns on Wikipedia as well...

Example code:
https://github.com/mspnp/microservices-reference-implementation

By the way: in https://github.com/mspnp (Microsoft patterns & practices on GitHub) you'll find lot's of interesting example code on patterns. Well worth visiting!

Past Wednesday Evening Trainings

You'll find post of previous sessions here: https://www.linkedin.com/search/results/content/?keywords=%23wednesdayeveningtraining

Next Wednesday Evening Training

Next Wednesday Evening Training, we'll have a "klusavond" in which we'll work on our projects. In the photo below, you'll see Aish already busy preparing the hardware :).

#capgemini #werkenbijcapgemini #lifeatcapgemini #wednesdayeveningtraining #microservices #microsoft #java

Innovation labs are NOT about furniture, bright colors, beanbags and ping-pong tables. It's about people.

Innovation labs are NOT about furniture, bright colors, beanbags and ping-pong tables. It's about people.

CoZone is also the place in which our Wednesday Evening Training (see my other posts) is held. It is an inspiring environment in which we feel free and in which we are constantly stimulated to find and invent things.

Read about Capgemini's experience providing a CoZone (Collaboration Zone) in:
https://www.capgemini.com/2018/07/people-the-backbone-of-every-innovation-lab

This week's Wednesday Evening Training: continuing our 3d and IoT projects and a bit of Windows programming

This Wednesday Evening Training, we continued our exploration of IoT and 3D technologies and learned about Windows programming.

Also: a special welcome to our guests from Siemens Germany: Florian, Alexander and Achim.

Windows DIB Buffer and Sound Buffer

First we had a nice demo and code walkthrough of our colleague Quincy Jacobs, who has experimented with the Windows DIB Buffer and Sound Buffer using good old C++/C. This ignited a lively discussion on wave and sound generation and techniques used for that. It took me right back to the era of home computers, in which I experimented a lot with the Commodore 64's SID (Sound Interface Device) programmable sound generator chip. Revolutionary for it's time (see also: https://en.wikipedia.org/wiki/MOS_Technology_SID).

BabylonJS

Next, I gave an update on my BabylonJS Archimate model project. This week, I had implemented an Observer to keep the Archimate (JavaScript Object) model in sync with the BabylonJS model. This enables the 3D model of the architecture being updated at runtime. I abandoned the proxy approach that I mentioned last week, since this is not supported by IE (in Edge it is supported) and IMHO it's too early to exclude IE. Instead I used a classic Observer implementation in JavaScript. We did a code walkthrough and discussed application of the Observer- and Factory pattern in general and in JavaScript. There is interest to plan a separate knowledge session on BabylonJS and WebGL. BabylonJS is based on WebGL (Web Graphics Library), which is a JavaScript API for rendering interactive 2D and 3D graphics within any compatible web browser without the use of plug-ins.

To be continued...

RFID (Radio-Frequency Identification)

As promised last week, we took a look at RFID technology. Roughly speaking: using a reader/writer  your application can interact with RFID tags (e.g. in your security card). Your RFID tag provides a unique id to your application, which you can use as a key in your database. In a nutshell this is the basis of access and registration systems. At very low costs, a few Euro's actually, you can have a lot of fun in your IoT project! See the links below for resources on this.
We could use RFID labels and a scanner for building an interactive toy for young children (see my last week's post on this). Based on RFID and Lilypad Arduino technology we should be able to create some kind of easily foldable and transportable carpet on which you can place all kinds of tagged objects and interact with them using an sowed in Lilypad Arduino.

Anyway... a lot to learn!

Further reading

Do you want to read more on the topics in this post? Here are some links...

RFID: https://en.wikipedia.org/wiki/Radio-frequency_identification
Tutorial 12 for Arduino: RFID Card Reading: https://www.youtube.com/watch?v=gIlSLwcbeTU
What is RFID? How RFID works? RFID Explained in Detail: https://www.youtube.com/watch?v=Ukfpq71BoMo
MF522 RFID Write data to a tag: https://www.youtube.com/watch?reload=9&v=uihjXyMuqMY
RFID Programming Made Simple and Cheap: https://www.developer.com/net/article.php/3628811/RFID-Programming-Made-Simple-and-Cheap.htm
BabylonJS, see my previous 19th july post: https://hansrontheweb.blogspot.com/2018/07/this-weeks-wednesday-evening-training_19.html
Understand the Factory Design Pattern in plain javascript (one of the many articles on this): https://medium.com/front-end-hacking/understand-the-factory-design-pattern-in-plain-javascript-20b348c832bd
The Observer Pattern in JavaScript explained: https://pawelgrzybek.com/the-observer-pattern-in-javascript-explained/
WebGL: https://en.wikipedia.org/wiki/WebGL

Past Wednesday Evening Trainings

You'll find post of previous sessions here: https://www.linkedin.com/search/results/content/?keywords=%23wednesdayeveningtraining

Next Wednesday Evening Training

Next Wednesday Evening Training, we'll take a deep dive into Micro Services. We'll discuss this from both an architectural point of view and a (Java) software engineering point of view. Demo's will be shown, code walkthroughs will be done and hopefully we'll have yet again a lively discussion!

Experiment, learn and have fun!


#capgemini #werkenbijcapgemini #lifeatcapgemini #wednesdayeveningtraining #3d #virtualreality #unity3d #babylonjs #arduino #rfid #iot #internetofthings #archimate #archi #patterns #windowsprogramming #c #c++