Passwort vergessen?

ALL YOU CAN READ!

Der One-Stop-Shop für mehr als 420 Magazine, Bücher und Ausgaben der Digitalbuchreihe shortcuts!

Finden Sie Ihr Thema direkt in unserem großen Archiv!


Von Machine Learning bis Domain Driven Design. Jetzt registrieren und sofort über 100 Seiten Expertenwissen erhalten.

Lesen Sie mit unserem neuen Premiumservice mehr als 420 Magazine, Bücher und shortcuts online. Mit dem entwickler.kiosk-Abonnement greifen Sie ab 9,90 Euro im Monat auf das gesamte Sortiment im entwickler.kiosk zu. Bestehende Abonnenten lesen in unserem entwickler.kiosk ihre abonnierten Magazine kostenfrei.

Registrierung

  • Mit Absenden der Registrierung bestätigen Sie unsere AGB und Datenschutzbestimmungen.

Direkt bestellen

DIREKT BESTELLEN

Bestehendes Abonnement zum entwickler.kiosk-Zugang erweitern

Bitte wählen Sie Ihr bestehendes Abonnement:

Volltextsuche

Ihre Suchergebnisse für:

Entwickler Magazin S...

PHP Magazin 1.19

Windows Developer 12.18

Java Magazin 12.18

IPC & iJS 2018

15. bis 19. Oktober 2018
Hochstrasse 3 Holiday Inn City Centre
81669 , München - Deutschland

Monday - 15. October 2018

09:00 bis 17:00
[SOLD OUT] Angular-Workshop: Architectures and Building Blocks for Enterprise Applications

Angular, Google’s popular application framework for modern web-based solutions, brings component orientation, static type checking, and a breath-taking performance. By leveraging the single-page application architecture as well as modern web standards, it makes the creation of ambitious and enterprise-scale applications very easy. This workshop shows the possibilities of Angular and introduces it with an example application. It shows all its building blocks and discusses architectural decisions one has to deal with when building maintainable enterprise applications.

Keine Slides vorhanden
Progressive Web Apps Using the Angular Service Worker

The term Progressive Web App (PWA) refers to a group of technologies, such as service workers and push notifications, that can bring native-like performance and user experience to web apps. PWAs are interesting because in some ways they represent a coming of age for the web. The Angular Service Worker makes it easy to build snappy web apps that load instantly on any device, even without an internet connection. Take advantage of the searchability, shareability, and no-install-required-ability of the web without compromise. During this 100 % hands-on session we’ll have a look on recent tools and guides from the Angular team to help us build Progressive Web Apps. We’ll have a look at Angular CLI and plugins/libraries for App Shell, Service Worker, and Application Manifest supporting us in fast and easy creation of installable, offline-capable, mobile-network-friendly apps. Course overview: Introduction to PWA and Workshop Setup; introduction to Angular Service Worker; create an installable mobile web app with Angular CLI; make the App Installable with Web App Manifest; App Shell Architecture; add an app shell component to the App; deep dive into Service Workers; add basic offline capabilities with Service Worker; adding Splash Screen; sending Push Notifications; questions and answers.

Workshop: Code like a Pro

​No matter how experienced you are as a developer: You can always improve. This workshop teaches advanced coding techniques through live coding. First up, we will solve some interesting coding problems that the audience has defined (it's only live if nobody knows the problem beforehand). In the second segment, we will write code in a test-driven fashion. In the afternoon, it is your turn to write code. You will work on an interesting non-trivial coding exercise while being individually coached by the trainer. It's your choice whether you want to try test-driven development, write code first, then tests, or write no tests at all. The latter, however, might earn you some angry looks from the trainer. We will touch on domain-driven design, test-driven development, clean code and SOLID principles, and might even throw in a few design patterns. Every question will be answered! Make sure to bring a laptop with your favourite development environment (current version of PHP, an IDE, and PHPUnit). Attendees should have a good working knowledge of PHP, at least basic OOP skills, and be familiar with the basics of PHPUnit. No frameworks or other third-party code will be needed.

Keine Slides vorhanden
[Sold Out] Getting started with Vue

When you are planning to implement a single-page application there is no way around Vue. At least you should consider using it in favor of the big established frameworks such as Angular or React. Vue is a very lightweight but yet capable framework you can use to solve even complex problems. In this workshop we are going to develop an application based on Vue, starting with the initialisation of the project with the Vue CLI to managing the application state with Vuex and navigating through the application with the router to debugging the application with the DevTools. There is plenty of time to try it out by yourself and work on various exercises to get used to Vue.At the end of this day, you'll know how and when to use Vue and the ecosystem that was built around the library.

Keine Slides vorhanden
Symfony 4 for Large and Small Projects

In a world where the front-end is evolving so fast, it is especially important to be able to count on a solid technology for your back-end that holds the foundations of your project. Symfony is a mature framework that had already proven its capacity of enabling rapid and good quality development, both for small prototypes and large and complex systems. Symfony 4 moves further in this direction, cutting configuration times to the minimum, and becoming more flexible and powerful than its previous versions. We will see how to turn Symfony 4 into your best ally for every project. Starting with a fresh installation, we’ll go through the process of building a Symfony application as well as a RESTful API and an admin panel – some of the most common requirements in almost every project. Along the way, we will review the best practices, learn how to organize the architecture of your project, and you'll hear about many useful tips and tricks learned along the years working with this framework.

[SOLD OUT] React Workshop: From Zero to App

You’ve heard about it. Maybe you even started looking at it, but you abandoned when you saw that you needed to relearn all you thought you know. When starting to do your first steps in React, the learning curve can seem really steep. In this workshop, the attendees will be guided through the fundamental concepts behind React and will learn how to build a full application using that technology. Covering packaging with webpack, routing, form manipulation and authentication, this workshop will get the attendees up to speed with the latest trendy framework that React is.

Tuesday - 16. October 2018

09:00 bis 09:45
Is a new Cross-platform Development Era coming?

Having a single codebase for the main mobile platforms applications is a Holy Grail for many developers. There are some different approaches like using some existing programming languages (not related to mobile dev) and “compile” to native, or creating a synthetic language, or using JavaScript and wrap by the native code (or run in VM). The results are often slow, cumbersome and quite far from having real “native” feeling. What if we want to add more platforms like native desktop apps and web-based ones? The listed methods will not help us there at all. What could be the real unifying factor for the app platforms we have now, both mobile, desktop and web-based? Right! We have browsers everywhere, that means we can run JavaScript everywhere and the only questions are how to “unbind” it from online-only usage pattern, how to give an access to main hardware APIs without any plugins, and how to let the apps out from the browser UI. Progressive web apps idea is gaining momentum among web developers, but let’s have a look at it from the mobile developer’s point of view. Is this a real new cross-platform silver bullet?

10:15 bis 11:15
PWAs - The Web is ready, but what about the Users?

Mobile First was yesterday, Offline First is the new motto. With this credo, Progressive Web Apps (PWA) not only come very close to native smartphone applications, they also increase the user experience when there is no or very poor internet connection and they no longer have to be delivered via App Stores. For years, users were taught to go to the app store, download and install the native app. How can we get them to move on and get engaged with the new user experience PWAs can deliver? This talk focuses on the user experience and acceptance of PWAs and gives guidance on how developers can get users to understand that new technology.

Keine Slides vorhanden
SPA Revolution with WebAssembly and ASP.NET Blazor

WebAssembly (WASM) is challenging JavaScript's monopoly in the browser. Many higher-level languages are currently evaluating whether WASM is a way for them to conquer the web client. .NET is spearheading this movement. In 2017, we saw the first .NET prototypes running on WASM. Based on that, Blazor, the new .NET- and WASM-based Single-Page-App (SPA) framework, has appeared. The .NET community is thrilled but Blazor could be interesting for developers new to .NET, too. Rainer Stropek engaged early in the Blazor open source project. Join him in this fast-paced, demo-heavy session and see what's behind this new contender in the world of browser development.

Optimized Angular Apps: Smaller, Faster, Better

Angular apps are getting more performant with each new version of the framework - thanks to the huge number of internal optimizations. But the main responsibility for the eventual app performance is on us developers. Let's go through the main points on how we could help the framework to build and the browser to perform our app better.

Angular and a Proxy to get behind the Border

For every JavaScript and Angular developer there is an invisible but well-known border – the Same Origin Policy. A well known issue that is also present in modern frameworks like Angular. To overcome this border Angular gives us something called a “proxy-config” so you can re-route calls for your middleware. With this concept you can use a complete development infrastructure with your frontend, instead of mocking everything. But what happens after the development? JSONP or CORS? Why not adapt what we have in our development stage? Use an express server as proxy config and get behind the border.

Getting started with Kubernetes

Kubernetes is a very powerful container orchestration platform that is quickly gaining traction and gives you lots of benefits in deploying, running and scaling your microservice web application. But it also has a steep learning curve. In this talk I will introduce you to Kubernetes, why you would want to use it and all the tooling around Kubernetes with the help of practical examples.

Do you verify your Views?

We all know how to test domain logic in isolation from framework, database, and template rendering. While testing framework and database interaction can be considered to be solved problems, there is room for improvements when it comes to the testing of views and their templates. Attendees of this presentation will learn how to decouple domain logic from views and make the latter convenient and fun to work with.

11:45 bis 12:45
Building Serverless Data APIs

Azure Functions, Microsoft’s serverless offering, allows developers to focus on their code and not be concerned about infrastructure or DevOps. And thanks to a slew of built-in integrations, it's also easy to have your functions get and send data to various services or even be triggered by events in those services. One such integration is with Azure Cosmos DB, the multi-model, globally distributed NoSQL data service. Cosmos DB exposes data as documents that you can access via SQL, JavaScript MongoDB, or Cassandra as well as graph and key-value store. In this session, you'll see how easily you can build an API from a set of Azure Functions that interact with Cosmos DB documents and some other services. We’ll go all cross-platform with Visual Studio Code and Node.js.

OAuth in Practice: Forgot Your Password? Yes I Did!

Every month, we hear about a new data breach and billions of user passwords are being shared as we speak. How can we stop this? There is a simple solution: Let’s stop using passwords! From email links to biometrics, more and more technologies are available to help developers handle different types of credentials. During this presentation, the attendees will learn about some of the alternatives and how to implement them in the context of an OAuth flow.

Search engine optimization for symfony developers

SEO is fancy, SEO is great, we just create content for Google." This is not a good motivation for a developer. Besides the semi-legal tricks of linkfarms and such, there are things that actually make a lot of sense to improve the ranking of our websites. Rather than turn to some dubious SEO expert, your customers should get good search engine support from you. In this talk, you will learn what you need to consider to make the Google algorithms happy and have nice looking search results. We will also take a look at the Symfony CMF Seo Bundle to see how SEO can be implemented in a project.

ES Modules: The Next Revolution?

Modules are an essential part of any non-trivial JavaScript application which requires more than a single code file. And while modules have been a standard part of JavaScript Since ES2015, it has taken browsers a while to support them. During this time, developers have turned to tools such as webpack, Rollup, and Browserify. These solutions have completely changed the way we write and deploy our web applications. But now that browsers are starting to support ES2015 modules, it's a good time to examine if these solutions are still relevant. In this session I will show why built-in browser support for ES2015 modules is a game changer, and how, when combined with additional new JavaScript features and network protocols, it can revolutionize the way we package and deploy web applications. I will explain in detail the benefits and limitations of browser support for ES2015 modules and highlight their advantages over existing JavaScript packaging solutions.

10 standards a PHP developer should know

Everywhere we look we see standards. The web is build on standards. Standards are great! They make it all work. Besides the W3C and other standard groups there is the PHP Framework Interop Group. Over the last couple of years they agreed on a couple of standards specifically for PHP. You might use some of them without even knowing about it. In this talk we have a look at 10 PHP standards, where they are or might be used and why they are useful.

14:15 bis 15:15
A Practical Introduction to Kubernetes

Kubernetes is an open source system for automating deployment, operations, and scaling of containerized applications. It currently is the most promising option you have for deploying your container-based applications to the Internet. In this session you'll get an understanding of the concepts of Kubernetes and the tooling you need to launch and maintain a PHP application in your own Kubernetes cluster. We will also take a look at topics like load-balancing, (auto-)scaling, persistent storage and typical fun killers which might spoil your Kubernetes party.

WebAuthn: Passwords are Legacy!

In March 2018, the haveibeenpwned.com password database contained about 501 Million hashes of known, stolen passwords. Yet, despite the fact companies obviously fail to securely store passwords and despite the majority of users still reusing a limited set of passwords for their online accounts, passwords are the predominant means of authentication. The brand new W3C Candidate Recommendation "Web Authentication" - or short WebAuthn - is supported by all major browser vendors and strives to make passwords a thing of the past. Get ready for the future and learn what WebAuthn is about, and how you can use and implement it for your site today.

Mastering Node.js Performance

Node.js has become a very popular platform for writing servers, in the web and the enterprise field. As it becomes present in more production systems, many developers encounter performance problems and need to understand how to optimise their server-side performance. What are the layers that we need to optimise in our engine? On which layers we should focus?   In this talk, I will give you tools to know where you should start looking for problems in your Node.js server. I will go through general performance tips, demo some profiling in Node.js, and talk about Node.js and JavaScript code optimisations that you should do. By the end of this session, you will have the tools to know where to start investigating your performance problems, and how to attack them.

Angular and Micro Apps: Maintainable Client Architectures

Big monolithic applications have had their days. What’s needed instead are smaller maintainable applications, aka micro apps, that can be developed and deployed independently by different teams. In this session, you'll learn how to implement micro apps in the world of Angular. By using several examples, we evaluate different approaches including web components, packages, hyperlinks or even iframes. As an alternative, we will also talk about the majestic monolith and see how monorepos can help here. At the end you will know your options and which approach works where.

Async Programming with TypeScript

Async programming is a must for scalable server apps and snappy web apps running in the browser. JavaScript has long been known for its “callback hell” when it comes to async. However, times have changed. JavaScript has learned new tricks and with TypeScript you can add type safety. In this session, Rainer Stropek speaks about server- and client-side async programming using TypeScript. He starts with type-safe promises. Based on that, he demonstrates the use of async/await without loosing backwards compatibility to old ECMAScript versions. Finally, Rainer closes with samples for using type-safe RxJS with TypeScript and Angular.

Keine Slides vorhanden
16:00 bis 17:00
Zend/Expressive 3 - The Next Generation

After the PSR-15 was finally published in the spring of 2018, the micro framework Zend/Expressive has archieved the next stage with its 3.0 release. Zend/Expressive suits all kinds of applications perfectly: from classic full-stack web applications via REST services through to special applications like PHP-based Alexa Skills. The third version of the micro framework based on Middleware can be your means of choice. This session introduces all the innovations in Zend/Expressive 3, presents different application possibilities, and demonstrates how to migrate from older Zend/Expressive versions.

Clean up Your Angular with Decorators and Reflect-Metadata

A few years ago, Google and Microsoft partnered up to work together on Angular and TypeScript. This partnership has helped TypeScript support two important features: decorators and reflect-metadata. Decorators are one of the cornerstones of our Angular code and, along with the reflect-metadata API, play a key role in the inner workings of Angular. These two features are based on active TC39 proposals and their importance goes beyond Angular. Once accepted into the Javascript standard, they can open the door for developers to implement exciting new features that were not possible to implement before. In this talk, we'll understand how decorators work, how to write our own custom decorators and take advantage of the reflect-metedata API to make your Angular code cleaner.

Browser APIs: the unknown Super Heroes

Still think browsers are only capable of parsing HTML, CSS and JavaScript? Think again! Browsers have become much more powerful and contain numerous APIs that can enrich the user experience or are just plain fun. This talk will introduce you to some of them (like Bluetooth, battery, speech, audio, location, ...) and show you how easy it is to unleash their power with JavaScript.

Serious Games: Verbesserung der User Experience (UX) auf Basis von Serious-Games-Theorien

In Serious Games werden Ziele, Regeln, Herausforderungen und Interaktionen genutzt, um die Motivation für Lernaktivitäten zu steigern. Lernen ist fester Bestandteil von Spielen und basiert auf Exploration und Erfahrung. Diese Motivation kann im Usability Engineering dazu genutzt werden, um langfristig die Benutzerfreundlichkeit von Applikationen zu steigern. Ich werde in meinem Vortrag die Theorie der Adaptivität aus dem Bereich der Serious Games vorstellen, welche verwendet werden kann um die Motivation bei der Nutzung mobiler Applikationen zu erhöhen. Diese Theorie haben wir in verschiedenen mobilen Anwendungen bereits erfolgreich eingesetzt. Basierend auf diesen Anwendungsfällen zeigt sich, dass die Verwendung dieser Theorie den Aufwand für die Generierung von Anwendungen nächster Generation reduziert und langfristig die Benutzerfreundlichkeit steigert. Ich werde darüber hinaus ein wissenschaftlich untersuchtes und industriell erprobtes Framework vorstellen, das in langjähriger Forschungsaktivität entstanden ist. Dieses Framework besteht aus einem Prozess und einer konzeptuellen Architektur, welche die Theorie der Adaptivität unterstützt.

The GDPR and You

You probably have a love/hate relationship with the GDPR, just like me. It may do a great job protecting our privacy, but honestly, even that remains to be seen. For most companies, getting ready for May 25th was... challenging. Now, as software architects and developers we must take responsibility and rethink many aspects of how we used to design and build systems. What does privacy by design really mean? How can we implement the right to erasure, especially in an event-driven world, and, most importantly, how can we prove to data protection authorities that we did things right? This presentation will provide you with a good mix of proven tactics, educated guesses, and some speculation. Do not expect complete solutions for everything (yet), but there may well be some eye-opening moments.

17:15 bis 17:45
Metamorphosis: From Database-Driven to DDD

  In Franz Kafka's famous German novel, Gregor Samsa awoke to find himself transformed into a gigantic insect-like creature. Julie Lerman was more fortunate. After decades of designing software based on the needs of the data to be stored, she woke up to the beauty of Domain-driven Design. On the IJS keynote stage, she will share some of big ideas from DDD about client collaboration, strategic design and tactical patterns to help you find a smoother path for solving complex software problems.

Wednesday - 17. October 2018

09:00 bis 09:45
Angular, React, Vue and Co. – peacefully united thanks to Web Components and Micro Apps

Web development is exciting nowadays! We get new innovative technologies on a regular basis. While this is awesome it can also be overwhelming - especially when you have to maintain a product for the long term. Web Components and Micro Apps provide a remedy for this dilemma. They allow for decomposing a big solution into small self-contained parts that can be maintained by different teams using the best technology for the requirements in question. Come to this keynote and find out how this idea helps with writing applications that can evolve over a decade and more.

10:15 bis 11:15
Sieben Tipps für den Voice Commerce mit PHP

Das Thema Voice Commerce wird schon seit 2017 entweder bejubelt oder verflucht. Ist das wirklich das nächste große Ding oder nur der neueste Flop des Jahrhunderts? Zwischen kritiklosem Jubel und ewiger Verdammnis werfen wir einen pragmatischen Weg auf das Thema und schauen auch, wie E-Commerce-Unternehmen einen ersten Einstieg in den Voice Commerce schaffen können. Die sieben Tipps starten in der Theorie und wenden sich über die Praxis auch direkt in die Tiefen der Implementierung mit PHP.

Node.js: Performance Analytics and Best Practices

You have just released your Node.js application and now it’s not performing as expected? No need to worry. Node provides you with a handful of tools to measure every performance aspect such as memory, computing time, and so on. In this talk I’ll show you how to deal with the code in your application when it comes to performance problems and how to use the tools you’ve got. We will also cover some best practices that help you to write applications that perform.

Processor Pattern with Angular Dependency Injection

Processor Design Pattern (Command Pattern) is a widely used in building enterprise grade software. In this session, I will share about how to utilise the awesome Angular Dependency Injection (particularly Injection token and multi provider) - to implement the pattern.

Internet of Things – Back to Basics

Using the internet as the communication medium for computing devices is nothing new. The internet itself was invented for this purpose. Nowadays the number and variety of devices using the internet for communication are increasing dramatically every day. With that, the technology became more and more accessible up to the point where the hardware required to build quite an advanced `internet thing` costs no more than an ice cream. The interesting part comes with the software required to make this hardware work and that is what this session topic is about. We’ll see how we can actually use low-cost hardware to build our own `internet things`.

11:45 bis 12:45
Data Sync in PWAs: Online/Offline

You can use Service Workers to speed up your application and make them available even when your device is offline. But there’s one problem: What happens to the data you created while being offline? You need to sync them back to the server. In this talk I’ll show you an approach that involves event sourcing to deal with this problem in a small real world demo.

Writing Security Code In Node.js

  Node.js has become more and more, and lots of enterprise and B2C application implement their server with Node.js. It is becoming importent to know what are the possible vulnerabilities in your Node.js server. In this talk, I will give some security tips in Node.js. I will show you what code can be vulnerable using built in Node.js functionality, and I will talk about the alternatives. I will also present several packages that can help you find vulnerabilities in your code and in your dependencies much more quickly , and pass your penetration testing much faster. As a developer, after this talk you will be able to write a more secure code in Node.js.          

Efficient Domain-Driven Design: An Introduction to Event Storming

Before the start of development comes the gathering of requirements. This daunting task with the seemingly endless discussions. Followed by the creation of epics, user stories or tickets which will change over and over again - even when development has already begun. We can do better than this: With Event Storming, an unlimited modeling space and all the key stakeholder in the same room. Let's get started with efficient Domain-Driven Design!

From Domain to Code with Domain Storytelling

We all love programming. But programming is not an end in itself. And how do we actually know, what we should program? For that we need a tool to learn about the domain.Domain Storytelling (www.domainstorytelling.org) means that we let our users tell us stories about their work. While listening, we record the stories using a pictographic language. The experts can see immediately if we understand their story. After very few stories, we understand the language of our users and can build a domain model from them and implement them in PHP or JavaScript.

Keine Slides vorhanden
A Journey Into Strategic Domain Design

One of the most relevant topics about Domain-driven Design is how to apply the strategic patterns to create organisational and technical designs aligned with the core domain of the company and maximize efficiency of the teams and infrastructure. The purpose of this talk is to show the journey of GetYourGuide in applying those strategic patterns to the travel industry in the marketplace business world.

Vue & Vuex

Vue.js is the new up and coming framework that has reached the same popularity on Github as React. Vue enables you to start easily with just script tags and upgrade to ES6 modules and Vue CLI when ready. It’s component centric and really lightweight. This talk will cover all the fundamentals of Vue and Vuex as the centralised state management made especially for Vue.js .

Keine Slides vorhanden
14:15 bis 15:15
Native JavaScript Modules: import {Browsers, Node.js}; export {production};

Techniques to organize JavaScript code as modules started nearly from the beginning of the JS history and went from separate files, AMD/CommonJS formats to bundlers/transpilers. Today, all the modern browsers support native JavaScript modules and they are halfway to Node.js. That means it’s a perfect time to start using them. This requires extending and optimizing the techniques we are bundling the JavaScript (aka ECMAScript, or ES) modules with today, changing the workflow and the way the code is executed. Also, it makes the new tools to develop and debug the ES modules. Today it's possible to load script synchronously, on demand and publish them to production, making sure all the code is still fully functional.Expect to hear about the main differences of the native modules (comparing to the bundlers/transpilers approach), how they work, and their features; how the browser/Node.js engines load and execute them and why it took so long for ES modules to be implemented in the JS engines; how to use native JS modules in production today; the benefits, performance overview, pros/cons, and conclusions; an overview of future perspectives and a number of examples/demos.

Keine Slides vorhanden
It’s Alive! Dynamic Components in Angular

The main use-case for using dynamic components is when we can decide only in run-time which component is loaded. They’re also the only solution when we want to embed Angular components in non-Angular ones. In many cases, replacing in-template components with dynamic ones is beneficial to performance and code quality. In this talk we’ll learn how to create and use dynamic components, and discuss several types of usages.

Web Component Architecture and Patterns

In this talk, we are going to look at what web components are, why we need them and how we can construct them according to best practices. In order to do this we will see several examples, and each example will be tackled with its own approach. Through these examples we will be able to see the pros and cons of different ways of structuring web components. Our journey will take us through different design patterns for developing web components such as MVC, MVP and MVVP. On this road we will discuss services and singletons, encapsulation, inheritance vs. composition and much more. Even though these concepts can sometimes be hard to grasp or even boring, we will explain them in a simple and fun way. We all know that you never write the perfect code the first time, there are always iterations. So, your goals should be: write code that is easy to understand, easy to refactor and easy to test! Also, it should often be easy to reuse but only when necessary (not all components need to be reusable but we will see more about that in our talk). We want to help you achieve this.

It's all about the domain, honey – DDD as basis for microservices

To build software, we use great technologies, programming languages, and tools. And we have a lot of fun programming in this technical environment. But we must not forget that the most important point for a successful project is not the technology but the *domain*! To understand the domain we need a common language with the domain experts. Also, if we don't reflect the domain model in the software and its architecture, it will not help our users doing their work.  It is easy for developers to fall into the trap of focussing on technology instead of  the domain. To prevent you from this, I will show in this talk how Domain-Driven Design (DDD) can help you to gather the domain knowledge and transform it into a Ubiquitous Language. To do this we use techniques like Interviews, Domain Storytelling, and Event Storming.In practice it is not easy to decide how to divide up the domain and develop microservices for it. Here the DDD pattern Bounded Context can help us. It shows us where vertical cuts can be made.Using these tools together with the Building Blocks of DDD enables us to build an architecture that represents the domain and makes our users happy.

Keine Slides vorhanden
PHP Inspections (EA Extended): realtime static code analysis

Php Inspections (EA Extended) is a PHP Static Code Analyzer for JetBrains IDEs. It extends static code analysis capabilities with 300+ rules focusing on potential bugs, performance, language level migration, architecture and other sensitive areas of PHP development. The talk will introduce the most profitable rules groups, automatic fixes capabilities and how to efficiently use the analyzer in typical integration scenarios.

Performance in a Personalized World

Good performance is a key success factor for public-facing software on the internet. Over the years, we have gotten pretty good at scaling content delivery, usually through a combination of heavy caching, cloud computing, and reverse proxies. But the world is changing rapidly, creating an increasing demand for personalization. Being able to deliver a highly personalized customer experience is very different from publishing static content. This talk goes in-depth on how personalization challenges established best practices to build high performance web applications, and provides you with proven solution blueprints.

16:00 bis 17:00
Getting Started with PHPUnit

If you want to be sure that your software works correctly, you need to continuously test it. Automated tests save you from pressing F5 in the browser all the time as well as from using debug statements such as var_dump() in your code. They are also cheaper than manual tests and easier to implement than you may think. How do I test my code with as little effort as possible? How do I execute as few lines of code as possible to test what I am really interested in? And what does this have to do with clean code? Attendees of this session will learn why they should include PHPUnit into their set of development tools.

Blockchain for Developers - What's behind the hype?

Within the next ten years, blockchain technologies will be a given in our software projects in the same way databases are today. In this session, Ingo Rammer presents the technical foundations of current blockchain technologies - without any hype or fancy crypto currencies which border more on tulip mania than on serious software engineering. You will learn about the basic elements, types and operations modes of today's blockchains; about the fundamental differences between public and private/permissioned networks. And you'll face the reality of smart contracts: that they are neither smart nor contracts, but simply rules to validate transactions in a reliable, distributed way - and a powerful base for projects spanning multiple organizations. After this session, you'll have a solid basic understanding to evaluate whether your use cases can be supported by blockchain-based technologies.  

Squash Bugs with Static Analysis

All developers know that bugs are bad and finding them can be difficult. The good news is that tools to help us find and prevent them are becoming more powerful. Modern static analysis tools (like Psalm, Phan and PHPStan) are far more advanced than their predecessors. They can find a whole range of bugs whilst keeping the false positive rate low. This talk introduces more advanced static analysis. It will show the kinds of bugs that the more advanced static analysis tools can find. We'll then look at how they can be added to your current development work flow. Finally, we'll look at how we can write our code in a way to get the most out of static analysis.

Angular Architecture Patterns Starring NGRX

It's easy to just build an app with no real architecture in mind. For the most part, Angular as a framework ensures that you don't drive off the road. However, as your application grows it becomes more and more apparent that you need to organise your code in a better way. The application state grows and suddenly it's everywhere and you realise you don't know anything about anything. This is where NGRX comes in to bring order to the chaos. NGRX ensure that your data flows in one direction and that you always know who did what to your state. Are you curious on what NGRX is and how to get started with its paradigms, libraries and tools? Then this session is for you.

Keine Slides vorhanden
Deploying IPv6

Many developers are stuck in the world of old-school IPv4, which is an easy and comfortable place to be. But IPv4 is not much longer for this world - major network allocations have already run dry, and broadband and 4G mobile networks are steadily expanding the availablility of native IPv6 connectivity. This talk helps you learn what IPv6 is, what you need to do to get your services working on IPv6 (it's not as scary as you might think!) and related changes you need to make in your PHP apps and databases to accomodate IPv6.

17:15 bis 18:15
Brief Introduction to ReasonML

ReasonML is a functional programming language that has gained a lot of popularity and excitement among the React community in the recent year. In this talk, we’ll have a brief introduction to the language, how it has evolved, and the toolchain behind it; we’ll introduce the exciting features ReasonML offers; we’ll learn how to leverage them to build React components in a safer and simpler way using ReasonReact; and we’ll demonstrate some real code examples to showcase methods that can help you start using it - whether you’re starting a new project or considering it for an existing one.

First Words - How to get rid of a thousand Apps and regain your Voice

A talk about voice control advises the speaker to demonstrate the power of his voice – and that’s what this talk is going to do. But why deal with voice control anyway? Is it just because of the hype around digital assistants such as Alexa, Cortana, or Siri? I will argue that there is a general technological trend towards a unified interface. With the Internet of Things and household robots, we enter a world of ubiquitous computing that is not well suited for visual interfaces. This also applies for robots that will be directed mostly through voice commands. For me, the question of an acoustic interface arose in a blended learning context at Carnegie Mellon University, where we realized that human-computer interaction is often contaminated by over-complex visual interfaces. Using a live demo, I will demonstrate how to get rid of these obstacles. The basic insight is: Human language is the most complex API imaginable. Rethinking programming and interface design is a challenge that opens new and unforeseen opportunities.

Keine Slides vorhanden
Event-Sourcing vs CRUD

Event sourcing is attracting more and more attention. This is partly due to the growing interest in domain-driven design (DDD) and CQRS, to which event sourcing fits conceptually well. But like everything else, it is not a panacea: There are scenarios for which event sourcing is excellently suited, and others where it is not appropriate. Golo Roden examines the scenarios involved and discusses the advantages and disadvantages, identifies risks and dangers, but also opportunities and possibilities. If you are not sure if event sourcing is the right approach for your application, this session is for you!

Keine Slides vorhanden
I am just a PHP developer

Is that true? Does the world of pure PHP developers still exist? Living in cross functional teams, would it be possible that one can sit on an island and say "I do PHP tasks only". What if the ops guy is ill? What if our angular hero is on holiday? This talk will walk you through common tasks in a "normal" web project. Lots of examples will show a divergent world of developing web applications. From ops stuff and build tooling to examples in an aAngular frontend. Somewhere in between there is still some PHP left.#

Making PHPUnit Better

Join Sebastian Bergmann, the creator of PHPUnit, to learn how PHPUnit works, why it works like that, why he wishes it did not work like that, and what he is doing about it.

Thursday - 18. October 2018

09:00 bis 10:00
AssertTrue(isDecoupled(“my tests”))

“Houston we have a problem! This change you want… Well, it’s one small change for the codebase but one giant change to the test suite!” We all know why tests are great. But every once in a while we just wish they’d never been written. One case when test regret occurs is when we want to alter our functionality slightly but in doing so half the test suite goes from green to red. This talk will investigate why this happens. In particular, it looks at the coupling between tests and the code under test. We’ll investigate ways of reducing this coupling and make out test suites more resilient to change. This talk is aimed at those who already write tests and have a good understanding of SOLID principles.

Using RxJs to Process Streams in Real-Time

In this talk you'll get an overview of Reactive Extensions and see its usage in a live-coding session.  First you will get an introduction into Rx and its history. After covering the basic concepts and terminologies, we will get a better understanding of observables and learn how to use marble diagrams for documentation. In the live-coding session I create a morse code generator to demonstrate real-time stream processing in a playful way. You will get basic knowledge in morsing and a lot more over RX. I will show you: how to create observables, common operators to transform streams, different ways to combine streams, subscription handling, error handling, exposing observables, andhow to use subjects to control streams. After the session you'll have enough knowledge to start using Rx in any language, not only in JavaScript.

Analyzing Large Datasets with JavaScript and Node.js

The ability to transform raw data into actionable insight is critical to business performance. As businesses continue to consume growing volumes of data, the importance of having the right tools to collect, process, and analyze that data increases exponentially. In this talk, Philipp Burckhardt will discuss tools and techniques for analyzing large datasets with Node.js and JavaScript. Philipp Burckhardt will first address design patterns for data collection, focusing on stream and command-line interfaces. He will then discuss current Node.js libraries and toolchains for stream processing, statistical analysis, and machine learning. Next, the speaker will introduce techniques for analyzing large datasets, with an emphasis on exploratory data analysis and visualization. Finally, he will identify opportunities for community development of next-generation tools.

Hello, My Name is “if”

Me and my little brothers “else”, “elseif” and my bigger sister “switch” are most likely all over your codebase. Often, we make your code harder to read or even difficult to understand. And don’t get me started on testing, we cause this thing called Cyclomatic Complexity, and I’ve been told that’s bad. Sebastian will show you that me and my siblings are similar but not equally bad even on a op-code level. He will show you some elegant and effective ways to get rid of us and make your code more comprehensible and easier to test. Do you want to understand this Cyclomatic Complexity thingy, how it affects you, and how it can be improved by writing more readable and maintainable code? Then don’t miss this talk.

Keine Slides vorhanden
Removing the Product Owner from the Agile Equation

One of the twelve principles in the Agile Manifesto tells us that business experts and developers need to work together on a daily basis. Scrum implements this principle by putting a Product Owner into the team, that channels communication between business and development. But there is an inherent problem with how this limits collaboration and exchange of knowledge. With the ever increasing project complexity and market speed it is time for a reboot. The hard truth is that developers need to speak to stakeholders and vice versa. Let us show you how this can be less daunting than it sounds (and why there is no alternative).

10:30 bis 11:30
Effective Code Reviews

Code Reviews are a de facto standard for most teams. Either as a general four eyes principle, via pull requests, or as a real team meeting. Each and every one of these methods has their own pros and cons. Avoiding bugs is typically the main reason why code reviews are introduced, but how often do you really find serious bugs in your code reviews? This talk will give some insights into how to use code reviews as a method to establish a common understanding of code quality in your team. Using review tools is usually the second step in that process, after the developers have established a mindset for good quality.

StranglerApplication Pattern: a Legacy Frontend Use Case

The frontend community shifted from simple websites with jQuery to complex Single Page Applications with Angular, React and so on. With this community getting bigger and "older" there's another kind of problems that we need to solve. How to manage Legacy frontend codebases. But when we can call a frontend codebase “legacy” and how we can manage it in a safe way? During this talk we are going to see how we applied the StranglerApplication pattern to make an AngularJS 1.2 Application in a shiny new codebase that our team really love.

A Happy End for the Docker-for-Development Drama

When Docker hit the scene, many developers (including me) started using containers as a lightweight alternative to virtual machines. It was promising to use Docker as a local environment for development which would closely match the software running on the production servers. But the cake was a lie, all sorts of practical issues spoiled the fun.​ In this session I'll share what I learned throughout the last four years of using Docker as a development (and production) environment and how you can create your own set-up taking full advantage of the benefits containers provide.

React and Mobx: Reactive Architecture

I would like to introduce an old but new paradigm, Reactive one, compared to the imperative and declarative. After introducing and comparing it, I will start showing an example of the benefits of reactive programming using React and MobX.

Stencil: The Time for Vanilla Web Components has Arrived

Web development changed dramatically during the last years. With the enormous amount of JavaScript libraries and the new HTML5 standard, it is much easier to create web apps today. When building a web app, you will probably want to reuse some of the web components you built. But how can you do that with the current state of HTML? One of the new and emerging web standards is Web Components. The Web Components standard enables you to create reusable web components that include HTML, CSS and JavaScript. On the other hand, crafting raw components can be cumbersome. This is where Stencil comes into place. In this session you will become familiar with Stencil, a compiler that generates standard-compliant Web Components.

11:45 bis 12:45
DDD, event sourcing and CQRS – theory and practice

Numerous software projects fail not only because of the chosen technologies, but above all because of the lack of interdisciplinary communication. Developers and domain experts speak different languages and do not understand each other. In recent years, domain-driven design (DDD) has increasingly established itself as an approach to solving the problem. But how does DDD work and how does it relate to event sourcing and CQRS? The three concepts are often mentioned together, but are in fact independent of each other – but under certain circumstances they can complement each other very well. In the session you unravel the weave together with Golo Roden. He will also show you how to develop a cloud application with JavaScript based on DDD, event sourcing and CQRS.

Keine Slides vorhanden
An Ode to Boring Technology

Developers are known to have an inner drive to always find better solutions to their problems, but there is a predominant dilemma going on in today’s tech market: Developers are keen to learn new programming languages and frameworks while companies aren’t willing to invest heavily into knowledge with ever decreasing half-life. This dilemma can be resolved. Spoiler: New technology is not always the answer.

Keine Slides vorhanden
No Bullshit Performance - Replacement statt Refactoring

Mit Tools wie blackfire.io oder einfach Xdebug kann man schnell grobe Performancefehler finden. Aber wer schon mal die Performance einer normalen Produktdetailseite in einem bestehenden E-Commerce-System zu steigern versucht hat, weiß, wie mühsam es sein kann, auch nur wenige Hundert Millisekunden bei der Time to First Byte (TTFB) herauszuholen. Dabei ist die TTFB meist gar nicht das größte Problem, sondern der “First Meaningful Paint”. Also die Zeit bis der User die Seite tatsächlich nutzen kann. In diesem Vortrag möchte ich an einem konkreten Beispiel zeigen, wie wir die Ladezeit einer Shopproduktseite von über 5 auf unter 1 Sekunde reduziert und dabei die Testbarkeit und den Entwicklungsprozess vereinfacht haben. Dabei haben wir nicht versucht, das Legacy System (Magento) zu optimieren, sondern die Produktdetailseite durch eine Miniapplikation ausgetauscht. Um das bestehende Shopsystem nicht völlig ersetzen zu müssen, nutzen wir einen Nginx Proxy, der die Zugriffe auf das Legacy-System (Magento) und die neue Produktdetailseiten-App steuert. Dadurch haben wir eine moderne App und konnten die echte Performance viel einfacher im Frontend durch verschiedene Techniken wie Inline SVG, Service Worker Cache oder async js rausholen. Zusätzliche Vorteile sind 80 Prozent weniger Serverressourcen und ein viel schnellerer und zukunftssicherer Entwicklungsprozess.

Prepare for tomorrow, today

Currently, the PHP project actively supports PHP 7.1 and 7.2. The security support for PHP 5.6 and 7.0 ends in December 2018. Now is the time to prepare for this year's PHP 7.3 and plan for next year's 7.4. Attendees of this presentation will learn everything they need to know about PHP 7.3 and how to keep up with PHP's development so that they will not be surprised, at least not in a bad way, when PHP 7.4 and 8 come out.

Angular App Architecture: Don't get Lost in Structure

How should I structure my angular app to stay scalable? I want to show you some nice tricks and explain how to split your app into several modules and components. So you don't have to be scared, it's just Angular.

13:45 bis 14:30
Tales from the wrong end - a maintainer's story of open source & CVEs

I'm the maintainer of a *very* popular open-source PHP package - [PHPMailer](https://github.com/PHPMailer/PHPMailer). In December 2016, two critical remote code execution vulnerabilities were found in PHPMailer, affecting potentially tens of millions of sites. There's a lot that goes on behind a CVE number - I'd been involved in reporting some minor security issues in the past, but nothing of this magnitude, and never at the receiving end, so I found myself at the start of a steep learning curve and an emotional roller-coaster. This is the story of how I ended up as the maintainer of a major open-source project, dealing with the project, handling vulnerabilities, contributions, donations and more.

14:45 bis 15:45
Web Components - The Future is Here

Web development changed dramatically during the last years. With the enormous amount of JavaScript libraries and the new HTML5 standard, today it is easier to create rich internet applications (RIA). When building RIAs, you will probably want to reuse some of the web components you built. But how you can do that with the current state of HTML? One of the new and emerging standards in HTML5 is Web Components. The Web Components standard enables you to create reusable web components that include HTML, CSS and JavaScript. In this session you will get familiar with the Web Components standard and you will learn how to use it even today.

Keine Slides vorhanden
Angular Realtime Interactions with WebSockets

Using Angular and WebSockets, we will be turning physical motion into virtual motion in order to perform actions in our browser (navigation, event firing, etc). We will see the integration process step-by-step, resulting in a simple web application using WebSockets, Angular and a plain WebSocket client/server Node.js server. Once we launch this application on our phone, it will start sending device motion data from our phone to the browser, using the brand new device event APIs to capture our device’s acceleration, orientation and motion, and our Node.js server to perform the transmission. The browser will receive the motion data, and it will translate it into events and actions on the big screen. Tools that are going to be used are the WebSockets API, Angular, RxJS and a little Node.js server. Observable sequences will help us subscribe and listen to incoming messages, firing events in the process. The presentation will be interactive (users connected to the same network will be able to send data with their phone, too).

Frameworkless Frontend Development

As frontend developers we have a lot of options when we need to choose a framework for our new shining project. But there’s another option that we usually don’t consider at all: a frameworkless approach. Today it’s possible to create single page applications, even complex one, without any kind of dependency. During the talk I will talk about our experience in extrategy using the Frameworkless technique. Most importantly I will explain how we decide the right framework, or no framework at all.

Working in Autonomous Teams: Why & How

Two years ago, we transformed our company into a network of cross-functional and self-governing teams. So we learned the hard way which ingredients help teams to thrive on autonomy and which salt can spoil the soup. It is not about understanding boundaries. It is rather about deeply comprehending as well as mastering required mindset, behavior, and more...

16:15 bis 17:15
Crypto for Everyone - Libsodium in PHP 7.2

PHP 7.2 includes the libsodium cryptography library by default in the base language - the first time that a popular language has shipped with strong, modern crypto support as standard. Everyone can build secure apps without the risks of rolling their own crypto or using outdated libraries. So what's in libsodium? What kind of things can you do? What risks remain? You'll get a tour of cryptographic functions, how they have been done in the past, and how to switch to libsodium to give you a security edge.

Keine Slides vorhanden
Make your App Alive with Angular Animations

Animations in our web apps are usually an after-thought, however, with Material Design Google has taught us that meaningful motion can improve the UI, help create context, and give direction. Angular has an amazing animations module which does most of the legwork for us in creating and managing these animations. This talk will cover how easy it is to get started with making your apps feel alive.

From Plain to Progressive: Angular-made PWA's

Web applications leverage the power of computers and wi-fi connections to give their users a fast, fluent experience. Nevertheless, a huge portion of web activity is done on mobile devices, which require different capabilities, such as minimizing data usage and power consumption. Native mobile applications also leverage the devices’ features to add functionality and engage the users. Modern web technologies and rapid browsers’ advancement allow us to use most of these features from within web apps and adjust them for slow connectivity and offline usage, while keeping their advantages over native apps. Moreover, we can run these applications on desktop browsers and enjoy the same enhancements. In this talk Shmuela will present the wonderful world of possibilities with Progressive Web Applications, and how to easily achieve these enhancements in an Angular application.

Progressive Node.js Framework with Nest

Nest is a framework for building efficient, scalable Node.js server-side applications. It uses progressive JavaScript, is built with TypeScript (preserves compatibility with pure JavaScript) and combines elements of OOP (Object-oriented Programming), FP (Functional Programming), and FRP (Functional Reactive Programming). In this talk you'll learn why Nest.js could increase your productivity and how to unlock your full potential as a JavaScript/TypeScript developer.

Friday - 19. October 2018

09:00 bis 17:00
Pragmatic TDD

Developers still hesitate to include writing tests in their everyday routine. There are numerous excuses, myths and misconceptions around: “they slow us down”, “we’ll never achieve 100 % code coverage, so why bother”, or “takes too much time to learn testing, we’re better off writing business logic instead”. When we get to the topic of writing tests first, the debate becomes even more heated. In the real world, where you get paid by code that ships, developers strive to write the most efficient tests possible to cover mission critical code and to quickly decide whether writing a functional test or series of unit tests is the best approach. Let us learn together how to use PHPUnit and TDD in the most efficient way possible, for extraordinary results. This workshop is for developers that start their projects by drawing a model of the database first, developers that are overwhelmed by the number of testing tools, don’t know where to start or simply want to level up their game.

[SOLD OUT] Workshop: Building Reusable JavaScript Web Components

Web development changed dramatically during the last years. Today, more than ever, when you are building your front-end you will probably want to reuse components across your application. But HTML elements are very limited, so what can we do? In this full day workshop, we will deep dive into ways you can componentize your front-end. We will start by presenting the new HTML5 Web Components standard. Later on, we will explore delve into Stencil compiler, which can help you to build web components faster and with ease. At the end of the day we will see how to work with different data flow patterns to make components interaction.

Event-driven development and architecture

Numerous software projects fail. This is not only due to the technologies chosen, but often above all to a lack of interdisciplinary communication. Developers and professionals speak different languages and do not understand each other. Golo Roden shows in this workshop how event-driven development not only lays the foundation for better maintainable software, but also reduces the language gap. The participants develop a software from the idea to the finished implementation. This way exactly what the customer really wanted is created.

Keine Slides vorhanden
[SOLD OUT] Workshop: How to Stop Sucking and Create Good Architectures Instead

"How do we get great designers? Great designers design, of course" (Fred Brooks). "So how are we supposed to get great architects, if they only get the chance to architect fewer than a half-dozen times in their career?" (Ted Neward). In 2012 Ted Neward came up with a great idea how to solve these problems: Architecture Kata - starting with just a couple of requirements, small teams can try to get an architecture vision within a short time. It is a process that helps you learn how to get started and what to focus on. It points out how important it is to understand the requirements before you start coding. This workshop will show you how this can be used to train methods like event storming within your teams, or how to train developers without the risk of a real project that could fail. Architecture Katas are a way to learn from each other and give you a safe way to learn from your mistakes.

X
- Gib Deinen Standort ein -
- or -