Programming in Practice - Information Computation

Published 8/2023
Created by Mariusz Postol
MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHz, 2 Ch
Genre: eLearning | Language: English | Duration: 16 Lectures ( 7h 6m ) | Size: 6.11 GB

Information Computation Fundamentals, Information Implementation Using Types, Algorithm Implementation Design Pattern

What you'll learn
Understand programming fundamentals selected topics including but not limited to terms like information, algorithm, coding system, data, program
Explore how to use custom types to represent process information
Take another look at an object-oriented programming concept and its applicability scope to define a contract between separate concerns
Understand the main idea and scope of usage of anonymous, partial, and generic definitions to represent process information using types
Design a program with unidirectional dependencies compliant with layered design patterns in practice and as a result leverage teamwork
Learn how to implement bidirectional communication of layers engaging callbacks, events, reactive programming, dependency injection, and inversion of control
Re-examine the dependency injection (inversion of control) design pattern to implement independent testing of separated concerns

Requirements
You should clone in advance the GitHub mpostol/TP repository on your computer and make sure you can open, build, and test the InformationComputation solution
It is not necessary but should be helpful to pass the course Programming in Practice - Executive Summary
You should be familiar with programming fundamentals and understand the following terms: instruction, method, value type, reference types, class, interface, etc
No programming experience is needed but some skills related to object-oriented programming fundamentals are helpful

Description
The course is about information computation in practice. We will start with the statement that the course title is a bit provoking because information is abstract and cannot be directly subject to processing by a computer even if the computer and implemented algorithm make up a powerful artificial intelligence bot that is capable of understanding human speech and producing in-depth writing that humans easily understand. While learning, we distinguish the following terms: process information and algorithm. The process information describes the state and behavior of a physical process in concern. In turn, the algorithm is a knowledge describing how to solve the problems related to the physical process in concern. The course addresses topics that are vital for overcoming in-practice this inconsistency to employ computers.The main goal of the course is to concentrate on learning - it means focussing on knowledge adoption. I focused on learning rules related to information computation but not training in a particular language or development tool. To make the learning outcomes practical examples are indispensable. To avoid overloading the examples with details unimportant for investigated topics I propose to apply extended examples. By extended examples, I mean examples that can be executed as independent unit tests. 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. By design, the unit tests are used to validate the correctness and consistency of a program. The role of the unit tests included in the attached examples 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. 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. This course is a member of the course suite titled Programming in Practice. Hence, more details about the rules overseeing this course you can find in the independent free course titled Programming in Practice - Executive Summary - consider enrolling and passing it if didn't yet.Information Computation FundamentalsYou will learn that the process information is an abstraction and, hence, cannot be subject to processing by any physical machine, including computers. This inconsistency can be overcome by applying coding systems. In reality, this way, we are computing the data but not the information. Fortunately, this way we can address the challenge that the same information could have an infinitive number of representations. We need a driving force - an engine - to realize the processing. Today it is a binary computer. Hence, in the context of information computation, we must deal with two kinds of information: process information and algorithm. The process information describes the state and behavior of a process in concern. In turn, the algorithm is a piece of information on how to solve the selected problem. Both are tightly coupled and must be represented together using a programming language, which is suitable to be used as a recipe of the computer behavior and information representation of a process in concern.Computers are programmable devices and need a kind of program to be controlled. To accomplish it, we use high-level languages based on an alphabet derived from the Latin alphabet. Syntax of these languages is founded on keywords borrowed from the natural English language and semantics supports object-oriented programming concept. Informally, they are designed to produce text that is more human-readable and easier to use. Modern languages consistently use the type concept to describe process information representation and algorithms implementation. The section spent on recalling information computation fundamentals is an entry point to further learning selected aspects related to types applicability and design patterns of the program text. The object-oriented programming concept is the foundation of this learning path.Information Representation Using Types and object-oriented programmingIn this part of the course, we recognize the type definitions as a part of a programming language that is a set of syntax and semantics rules governing a text of a computer program. The main idea behind custom types is the possibility to represent practically any process information to be the subject of computation. Types are used to control the program consistency if the programming language is strongly typed, therefore could improve the robustness of the development outcome. The course prepares you to define new custom types. You will learn that using modern programming languages, new types may be defined from scratch or derived from existing ones. To accomplish it very helpful is the object-oriented programming concept. Additionally, the application of this concept allows us to solve polymorphic problems and organize the interoperability of software program parts using abstraction, inheritance, and encapsulation. The abstraction may be recognized as a contract used to harmonize the development process of the software program parts. During the course, we spent also a reasonable amount of time learning selected text management mechanisms enhancing the type definitions process. After the course, you will understand the main idea and scope of usage of anonymous, partial, and generic definitions to represent process information using types.As a result of using anonymous types, the compiler infers type definition from the expression evaluated as a value. During the course, we get more about how to use this definition method of a custom type to represent external data and use it for consistency checking. External data is not subject to detailed examination but it is recognized as data managed outside of the process hosting the program. Typically, for strongly typed programming languages, the type of a variable may be devised by a developer or inferred by the compiler. During the course, we examine the next option, which is an auto-generation of the required type definition from metadata using development tools. During the course, you learn more about how to blend autogenerated parts with the developer ones. The possibility of reusing the outcome of previous work is extremely important because it improves economic efficiency, is beneficial for reliability, and minimizes training costs. The generic definition concept is a next text management programming language feature that allows automation of the custom type definitions by using parametrized templates.Algorithm implementationProcess information representation and algorithm implementation are tightly coupled and must be the subject of a computer program development using a selected programming language. Computer programs begin their life cycle as the text that must be compliant with this language. The course addresses methods and patterns that may be applied to manage the program text as one whole with the purpose to make teamwork easier, allow independent testing, decoupling the development outcome from the technology change, and make scalability easier, to name only the most important. To decrease the production cost and improve robustness, it is proposed to organize the computer program text into autonomous fragments addressing typical responsibilities. There are many design patterns applicable in this respect but the layered design pattern is best suited to be applied to the program as one wholeThe program development should be commenced by researching knowledge helpful to solve a problem in concern or achieve the computation goal. This knowledge as one whole we call algorithm. The separation of concerns is a very useful concept while working on algorithms. From sociology we know, that the separation of concerns improves our performance of thinking because as a result, we may think about independent topics with minimal overlapping between them. So to improve our productivity we must leverage separation while working on the computer program text. You will learn that the main challenge is to decide when and where we should deal with the separation of concerns - while thinking about the solution or while implementing it as a text.It is proposed to implement this separation by applying the program's layered design pattern. During the course we learn that thanks to this approach the following benefits may be accomplished: separation of concerns, simultaneous development, independent testability, resistance to changes in technology, and scalability. Finally, you will learn how to decrease development time and time to market. Usually talking about a layered design pattern applied to the program as one whole we may distinguish three layers: the presentation, logic, and data layers. Getting more about implementation, the responsibility of layers, and the expected benefits are the next learning outcome. Layers may be implemented using sets of custom-type definitions. These definitions must either be self-contained within the layer, or they may depend on declarations that are exposed by the layer beneath it. During the course, you will learn how to recognize the membership. To make the layer unambiguous it must be assumed that any type belongs only to one set, to one layer. This way we convert the discussion about mathematical sets to the examination of types grouping. The main goal is to keep the discussion as practical as possible.By design, the layered program design pattern means its organizations, in which we can distinguish independent entities of a program related to each other making a top-down hierarchy. The top-down relationship means that the layer above only refers to the declarations exposed by the layer below. You will learn that it is a compile-time pattern. At run-time, we must consider control flow and data flow in both directions between layers. Hence, the next challenge addressed by the course is how to implement the bidirectional communication of layers at run time using a unidirectional dependency relationship. You will learn that inter-layer communication may be categorized into control flow, data transfer, and event notification. During the course, to make the learning outcome practical, we explore various examples of interlayer communication, including but not limited to properties, callbacks, events, reactive programming, and dependency injection. Some of them may also be referred to as inversion of control.The next part of the course covers the applicability of the dependency injection design pattern in practice. During the course, it is stressed that the main point of this design pattern is an assignment to an abstract variable a reference to an instance of an invisible type at the intended location for some reason. I named this pattern dependency injection to somehow distinguish this scenario from using just object-oriented programming alone. In this case, we are using object-oriented programming to deal with the separation of concerns. One concern is the usage, and the second one is the implementation of a concrete type. Hence, shortly the dependency injection is a design pattern where we are using an abstraction in place of an unknown for some reason instance of a concrete reference type to transfer this instance from one place to another. You will investigate practical examples demonstrating independent testing and bidirectional inter-layer communication.This particular design pattern implements abstraction to create an agreement between the creation and usage of an instance. The abstraction is employed to specify the property type (property injection) or the formal parameter type of the instance method or constructor (method or constructor injection). This design pattern eliminates the requirement for visibility of a specific definition of the concrete type in the program's intended location.

Who this course is for
Junior and middle-level software developers curious about improving their programming skills
Entry-level software architect looking for knowledge and skills required to carry out the architectural design of programs
Teachers serious about the improvement of the software development skills education methodology
Students that have accomplished classes covering Software Development Fundamentals or equivalent
Software development project leaders, who are responsible for teamwork management, documentation preparation, debugging, code optimization, etc

Buy Premium Account From My Download Links & Get Fastest Speed.