what you'll learn:
- You will know prerequisites, principles, and rules for the proposed new paradigm: Programming in Practice
- You will be able to select appropriate tools and familiar with the prerequisites that you must fulfill to implement the Programming in Practice educational path
- You will understand differences between software development skills educational approaches
- You will learn a new role of unit tests to improve the software development learning process
- You will be able to find and create a local copy of a GitHub repository offering the extended examples compliant with the presented concept
- You will be able to clone the repository using an integrated development environment
- You will understand the difference between cloning and copying to create locally a working replica of the program code
- You will know how to get feedback from a community in case of questions or doubts you may have
- You will be able to contribute and cooperate aimed at improvement of extended examples
- You will be able to provide feedback aimed at priorities of further development and improvements of extended examples
Requirements
- No programming experience needed. You will learn everything you need to know
Description
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 also spanning the practical issues of implementing computational systems using the software.
Software development needs programming. To improve your programming skills, you have the following options:
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 of your knowledge, but not skills.
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 if someone needs 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 that the code snippet is 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.
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.
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.
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 value 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 designing 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, 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.
External Data-Intensive Programming: process data management using external resources - the external data is grouped as streaming, structural and graphical data.
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.
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 the 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 collaborations 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.
Who this course is for:
- Middle-level software developer curious about improving programming skills
- Entry-level software architect looking for knowledge and skills required to carry out the architectural design of programs
- Teachers and lecturers serious about improvement of the software development skills education methodology
Post a Comment