Programming in Practice - Executive Summary

In this course, I will present an executive summary of the Programming in Practice educational path. If we are talking about programming, we must, of course, also talk about programs.  Generally speaking, we can assume that a program is an algorithm implementation. In this context, we may recognize implementation as a process of representing an algorithm using a language dedicated to being used by computers. Diving in computer science as a study of algorithmic processes, computational machines, and computation itself is a good topic for an independent course. Now, let me only stress that it is a discipline that also spans the practical issues of implementing computational systems using software.

Software development needs programming. To improve your programming skills, you have the following options:

1. You may learn the programming language as the principal goal and start programming from scratch. It leads to a theoretical approach, and finally, possible improvements in your knowledge, but not skills.

2. Unfortunately, a typical proposal may resemble the following scenario: if you need inheritance, reflection, serialization, dependency injection, inversion of control, etc. just do it... and here you are getting a snippet of a text illustrating how to implement the selected concept. It is like the Twitter style - deep thought expressed as a short text. Unfortunately, it teaches the humility of the teachers but not the skills of the students for sure. Additionally, this approach has a few subsequent drawbacks. By design, the examples are detached from the context. It means that they are not answering a question about someone needing something and what this something means. Additionally, this approach doesn't promote reusability because - intentionally - the examples are tightly coupled with details that exist only in the teacher's mind. Sometimes any simple modification of assumed details causes the code snippet to be useless for practical use cases because it is not self-contained. Concluding, teaching based on snippets promotes simplification. unfortunately, my point is that simplicity was not born by simplification.

3. The next possibility is to engage the full-featured program embedding an example. Unfortunately, it usually has a lot of unimportant details for the topic in concern. It could obscure the pattern and make the behavior hard to understand.

4. In other words, the examples are indispensable to make the learning outcomes practical but to overcome the drawbacks mentioned previously I propose extended examples. By the extended examples, I mean examples that can be executed as independent units. This way, you can observe not only a pattern but also trace the behavior. I believe that it should also improve the reusability of the examples.

5. 
   

Usually, unit tests are used to validate the correctness and consistency of a created program. The role of the unit tests included here is significantly different.  They are created with teaching values in mind. By design, they are used to make the examples intelligible and add the possibility to analyze also the behavior of the code patterns presented here. It is my silver bullet that allows diving into code samples behavior based on working examples. As a result of this approach, the examples are not obscured by a bunch of unimportant details needed to execute the examples as a part of a complete program. Of course, the testing and teaching roles cannot be entirely separated. A detailed description of the unit test design and deployment is to be covered by a separate course.

To make the code samples intelligible, they must be developed using an appropriate language and maintainable using coupled development tools. To be able to trace behavior, the development environment has to support it. I have assumed that all topics are illustrated using the C# language and opening with the MS Visual Studio design environment to ensure the practical context and provide solid examples. This course lets you get started with C# as a programming language and Visual Studio as an integrated development environment.

Let me stress again that the main goal of this course is only an introduction to how to get started to create a foundation for the Programming in Practice educational path. Programming in Practice is based on code samples that by design are reusable patterns. But code samples are just text. The text must be maintained in a public repository To promote reusability. To promote separation of concerns it is organized into independent but consistent sections. Today, the code examples address the following application domains.

1. External Data-Intensive Programming: process data management using external resources - the external data is grouped as streaming, structural, and graphical data.

2. Adaptive Programming: language constructs, patterns, and frameworks used at the development and deployment stage to improve the adaptability of the software in the production environment.

3. Distributed Programming: all about developing interoperable applications interconnected over the network.

Concurrent and real-time programming are just examples of the possible directions for the further development of the code samples collected in the repository. The assumption is that the priorities in this respect are encouraged by community feedback.

I have selected the GitHub repository to maintain the examples. One of the reasons is that it is a perfect platform for collaboration. Generally speaking, three forms of collaboration may be distinguished, namely

- using the content as is,

- reporting problems,

- actively contributing to code improvement

Independently, thanks to a very permissive license, the code may be used for other training courses or may be embedded in commercial applications. Finally, the Programming in Practice community could gather researchers, teachers, practitioners, and students working together on further directions of software engineering depending on the current priorities of the community promoting openness and transparency. Consider contributing aimed at improving and expanding the examples offered by this repository. The topic of how to contribute is covered in this course.