Title: Writing multithreaded programs in Pascal.
Summary: This workshop will focus on writing multithreaded programs in Pascal. We will go through the basics of setting up a simple multithreaded program. Then we will work on identifying problems that appear only in multithreaded code and will describe same ways to circumvent them. In the last session we'll see how we can focus on writing useful code (instead of fighting with multithreading issues) by using high-level parallel programming libraries. Most of the workshop will be suitable for Delphi and FreePascal programmers, except that examples and demoes will be using Delphi only.
Contents:
Session 1: Of threads and tasks
We will start by introducing background worker threads into a single-threaded programming world. After we have dealt with the standard support for multithreading, available in both FreePascal and Delphi, we'll just hint towards a different look at the multithreading - tasks.
Session 2: Locking
Splitting a program into multiple threads brings on you a whole world of pain. Suddenly you have to deal with problems such as resource protection. A simplest-if not the fastest-way of protecting resources is locking. We will look into different locking implementations and describe problems that can occur when locking is not correctly implemented.
Session 3: Messaging
A different approach to resource protection is resource splitting. Instead of threads having to fight for data we send them appropriate work chunks over some communication channel. We'll look at different possible implementation of such communication channels.
Session 4: High-level parallel programming
In this session we will focus on two parallel programming libraries that make life of a multithreading programmer much simpler (Parallel Programming Library and OmniThreadLibrary). This session will focus solely on the Delphi environment.
Instructor: Primož Gabrijelčič.
Bio: Primož Gabrijelčič has worked with Pascal since 1986, when he started to explore the language on a Sinclair ZX Spectrum. He later moved to CP/M, VAX/VMS and DOS, but stayed loyal to the language. For the last 25+ years, he has been developing systems for management and the real-time transmission of subtitles and teletext, which are used in many European countries. Most of that time, he has worked on writing multithreaded Delphi applications which resulted in a well-known open-source multithreading Delphi library, OmniThreadLibrary. He has written three books about Delphi programming, and he manages a technical Delphi blog, The Delphi Geek.
Title: Developing games using Castle Game Engine.
Summary: The course will be a practical overview of using Castle Game Engine to create 3D and 2D games, and building them for various platforms. The talk is also directed at both FPC/Lazarus and Delphi users. We start by developing a 3D game, designing level by combining assets in Castle Game Engine, adding physics and coding a logic to make shooting possible. We will move on to creating a user interface and adding more player logic, like picking up items and managing player life. We will then actually deploy the game on Android and use some Android-specific features, like Google Play Games. If the time allows, I'd like to also show deployment on Steam, along with Steam achievements. Finally, we will talk about adding spatial sounds and utilizing continuous integration like GitHub Actions.
Contents:
Session 1. Creating a level of a 3D first-person shooter
● Using Castle Game Engine to design 3D environment from ready pieces
● Add rigid body physics for environment interactions
● Use Blender to design non-trivial base level mesh
● Use Castle Game Engine editor to configure level and basic AI
● Code: shooting and bullet collisions using physics
Session 2. Designing user interface in Castle Game Engine
● Items on level: picking up
● UI for inventory
● UI for player life
● Extra stuff on HUD: Minimap, FPS, proximity sensors etc.
Session 3. Deploying the game to Android, integration with Google Play Games
● Building and testing the game on Android
● Using CGE services to manage a leaderboard and achievements in Google Play Games
● Using CGE services to send analytics to GameAnalytics
Session 4. Sound, states, savegames, using GitHub actions
● Using spatial and non-spatial sound effects
● Splitting your game into multiple states (note: it is possible I will decide to squeeze this topic into one of the earlier session)
● Saving persistent data (savegames)
● Using GitHub Actions (optional, if we'll have time)
Instructor: Michalis Kamburelis
Bio: Michalis Kamburelis is the lead developer of Castle Game Engine, an open-source 3D and 2D game engine using modern Object Pascal. The engine features a visual editor and a powerful and fast API, and it supports a range of formats for assets, including Khronos glTF and Web3D X3D. Michalis is also a member of Web3D consortium, helping to develop X3D standard, and a liaison between Web3D and Khronos consortiums to align glTF and X3D, two main standards for 3D models. Michalis is also a co-owner and CTO of Cat-astrophe Games LLC, an indie Polish game development company. He is also the lead maintainer of a documentation generator for the Pascal language, and he wrote the book Modern Object Pascal Introduction for Programmers.
Title: An introduction to deep learning with CAI NEURAL API.
Summary: This course will teach you how to program deep neural networks using CAI Neural API, a free and open library to create artificial neural networks with Pascal. We’ll start studying artificial neurons as dot product calculators and training individual neurons to compute Boolean operations such as NOT, AND, NAND and OR. We’ll use examples in both Delphi and Lazarus. We’ll also experiment with multi-layer neural networks for more complex Boolean algebra and basic image classification. For the first time with CAI Neural API, we’ll take the opportunity of the congress to debut CAI Neural API applied to the biomedical area. We’ll solve problems including image-based malaria infection detection and colorectal cancer detection at cellular level.
Contents:
Session 1:
● Neurons as linear functions (dot products).
● Learning boolean operations with neurons for operations NOT, AND, NAND, OR and NOR.
Session 2:
● Short introduction to backpropagation algorithm.
● Fully connected (dense) layers.
● Learning nonlinear functions with 2 layers of neurons: XOR.
Session 3:
● Convolutional layers.
● Basic image classification example with MNIST dataset.
● Visualizing first layer patterns.
Session 4:·
● Solving real problems:
-Identifying malaria (on the malaria dataset).
-Identifying colorectal cancer (on the colorectal cancer dataset).
Instructor: Dr. Joao Paulo Schwarz Schuler
Bio: Dr. Joao Paulo Schwarz Schuler has a PhD in computer science and mathematics of security from the Universitat Rovira i Virgili and a master’s degree in computer science from Universidade Federal do Rio Grande do Sul. He has worked for different software companies using Delphi as a software development team leader. Currently he is completing a doctoral thesis on convolutive neural networks. He is well known in the Pascal community for developing deep learning APIs for Pascal, called CAI NEURAL API, which has a GNU Lesser General Public License.
Title: Developing advanced Client/Server applications with Pascal
Summary: In this course we are going to see different technologies to be able to work in Client/Server mode. Communication between devices is something primordial in current application development, as a large number of programs require these features to be incorporated. Thus, this course can be very useful for all those who wish to be introduced to inter-application communication and those who want to update their knowledge on this subject. We will start with connection via TCP/IP Socket, an option widely used in different production environments. We will continue with REST API connections, and we will take a look at the different components available in Lazarus and Delphi. Finally, we will look at components that make use of the binary protocol MQTT (MQ Telemetry Transport) and the text protocol STOMP (Streaming Text Orientated Messaging Protocol).
Contents:
Session 1- SOCKET.
● Sockets are the basis of communication between computers and are still widely used to send information between the different components of a network.
Session 2- REST APIs.
● REST APIs are widely used to share information between different systems and are currently widely used in web development where we have a web application that connects to a web server where it communicates through its REST API to obtain the necessary data from the application.
Session 3- MQTT ( The Standard for IoT Messaging )
● MQTT is a protocol that works according to the principles of the publication or subscription model. In this way we manage to decouple the sender of the message (publisher) from the receiver of the message (subscriber).... As you can see, it is very interesting to be able to create systems. MQTT has become the most popular communication model for IoT applications because it is a low-power protocol for these devices, requires low bandwidth and has the ability to implement QoS to prevent information loss. Companies such as Facebook make use of this protocol in their chats.
Session 4 - STOMP (Simple (or Streaming) Text Oriented Messaging Protocol)
● You may be familiar with applications that make use of this protocol such as Apache ActiveMQ or RabbitMQ (even kafka has a plugin for STOMP). STOMP is a simple text message transfer protocol, designed to work with message-oriented middleware.
Instructor: Emilio Pérez
Bio: Emilio Perez, a engineer in computer science, works as a technology consultant and trainer. He has more than 20 years of experience in the software industry in both the training and development of commercial projects. He is also the founder and CEO of the company Abatic Soluciones Tecnológicas, and he has more than 2,500 hours of training experience in Delphi, SQL, PL/SQL, JAVA, PostgreSQL and WordPress, among other technologies. Since September 2013, he has served as Delphi MVP for Embarcadero. In addition, he is the creator of the podcasts No Solo Delphi and Aprende a Programar and a promoter in Spanish-speaking communities of free software, such as PostgreSQL and Delphi MVC Framework.
Title: Deploying and using cloud solutions with Delphi
Summary: The cloud is not the future, is the present. This workshop will start with the basics of cloud computing and we will slowly dive deeper into the possibilities that offers. Accessing remote APIs, creating your own (remotely or on-premise), or using serverless services like AWS will be just a few examples that will show you the potential and nearly endless options that you can take advantage of in your applications.
Contents:
Session 1: Introduction to cloud computing.
We will scratch the surface of the main concepts of the cloud (IaaS, PaaS, SaaS...), the different types of solutions it provides, and its applications in the world.
Session 2: Using Delphi to access remote APIs.
Connect easily to API REST endpoints using Delphi components and use the tool RestDebugger provided with RAD Studio to simplify the process.
Session 3: RAD Server: Publish your own APIs the RAD way.
Create your own API REST server connected to multiple databases and expose your data to the internet securely and granularly.
Session 4: Using serverless cloud services like AWS with Delphi.
Using AWS SDK for Delphi, take advantage of the multiple supported services from within your Delphi applications.
Instructor: Antonio Zapater
Bio: Pre-sales consultant engineer at Embarcadero inc. and certified Delphi developer. He co-owned a company for more than 15 years which develops ERP solutions for the retail sector using Delphi since version 7. Highly experienced with database modeling, legacy Delphi code migration, mobile development with FireMonkey, full-stack web development, API modeling, containerization as well as Linux services development using Delphi.
