![\"mutability](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1999\/mutability-data-types-alpharithms-1.jpg\" "\\"mutability-data-types-alpharithms\\"")
Mutability describes the ability of an object to be changed after its initial creation. Mutable<\/strong> objects allow such change while immutable<\/strong> objects can not be changed. These properties can be used to bound the behavior of programs by defining how the state of certain data is allowed to be altered. In some cases, mutability can restrict data from being changed at all!<\/p>\n Mutable objects are characterized by the ability to change their data. This property can be a direct result of a Data Type or an indirect result of a Data Structure. For example, an Array is immutable in the sense that its length is fixed in size but also immutable in that its elements can be replaced or, in some cases, even mutated. Here is a list of common mutable<\/em> objects:<\/p>\n Immutable objects are characterized by their inability<\/em> to be changed once they have been created. These objects simplify many aspects of programming, compiling, and run-time goals. They are thread-safe, won’t change state during thrown errors, don’t need copy constructors, and serve as overtly predictable keys for Data Structures like hash tables, sets, etc. Some common immutable data types are as follows:<\/p>\n Note<\/strong>: The keywords Recommended Course<\/strong>: Java In-Depth: Become a Complete Java Engineer<\/em><\/a><\/p>\n Recommended Reading<\/strong>: The Art of Immutable Architecture: Theory and Practice of Data Management in Distributed Systems<\/em><\/a><\/p>\n Control flow describes the order in which programming statements are evaluated. Control flow mechanisms exist from the lowest levels of CPU architecture in physical form to the highest levels of abstraction in computer language syntaxes. Examples of control flow mechanisms include the following:<\/p>\n Each of these represents logical tools by which programmers can control<\/em> the\u00a0flow<\/em> of their programs’ execution and\/or interpretation. The canonical control flow example is seen with If-Then statements where a program checks\u00a0if<\/em> a condition is present and\u00a0then<\/em> acts accordingly.<\/p>\n For example,\u00a0if<\/em> a car is turned on\u00a0then<\/em> one can start driving. Control flow statements often present alternatives should an\u00a0if<\/em> condition not be met. Using our car example, after the if-<\/em>then\u00a0<\/em>there might be an\u00a0else<\/em> statement that says:\u00a0else<\/em> turn the car on. Here’s another example, written in Python, showing a series of control flow statements:<\/p>\n If-Then statements aren’t the only means of control flow though certainly the most commonly recognized. A close alternative is the Switch statements where a variable is considered and multiple Case statements are provided to address each possible state. Here’s an example of a basic Switch statement written in Java:<\/p>\n Here we see a series of Note<\/strong>: Control Flow is not to be confused with Flow Control<\/em><\/a> \u2014another useful concept from the field of computer networking.<\/p>\n Recommended Course<\/strong>: Flow Controls – Fundamentals of Programming in Python<\/em><\/a><\/p>\n Recommended Reading<\/strong>: Effective Java – 3rd Edition<\/a><\/em><\/p>\n Design patterns are generalized, reusable approaches to solving common problems. There is an incredibly vast number of design patterns used across an incredibly vast number of software contexts.<\/p>\n The use of design patterns allows programmers and engineers to benefit from the collective work of others in solving common problems. Several popular and broadly applicable design patterns are as follows:<\/p>\n Design patterns can be created, adapted, or re-used to address common problems in many situations. Some are nuanced\u2014only applicable maybe to a few common problems a single design team faces for a specific project. Others are near-universal\u2014patterns that stand to benefit any team working on any software. Regardless of scope, design patterns fall into one of these four broad categories:<\/p>\n The origin of design patterns is credited to the book Design Patterns Elements of Reusable Object-Oriented Software<\/em><\/a> published in 1994 by the now-infamous “Gang of Four.” Design patterns aren’t requirements of effective<\/em> programming but almost certainly requirements of efficient<\/em> programming efficiency.<\/p>\n Recommended Reading<\/strong>: Head First Design Patterns: A Brain-Friendly Guide<\/em><\/a><\/p>\n Recommended Course<\/strong>: Design Patterns in Java<\/em><\/a><\/p>\n Object-Oriented Programming (OOP) accounts for many core features of modern programming languages. It can be characterized as a programming paradigm, often contrasted with functional programming, where “objects” model real-world concepts.<\/p>\n OOP\u00a0objects<\/em> contain data and operations with which programmers can manipulate the data by changing the state of an object. OOP is a\u00a0vast<\/em> topic and one many have dedicated the focus of their academic and professional careers to studying. Important concepts of OOP include the following:<\/p>\n Examples of primarily object-oriented programming languages include Java, C#, and C++ though other modern languages such as Python, JavaScript, and PHP all use object-oriented designs as well and, in most cases, are\u00a0designed<\/em> in an OOP fashion but do not require programmers to constrain themselves to the OOP paradigm.<\/p>\n Note<\/strong>: Python is an Object-Oriented language in how it is designed but allows programmers to use many other paradigms like functional programming. Languages like C# and Java are much more opinionated in their class-based OOP design and require an OOP-first approach.<\/p>\n Recommended Reading<\/strong>: Object-Oriented Thought Process<\/a><\/em><\/p>\n Recommended Course<\/strong>: Java Programming for Complete Beginners<\/em><\/a><\/p>\n Abstract Data Types (ADTs)<\/a> are high-level concepts that outline how data can be stored and manipulated. They provide the conceptual framework for\u00a0what<\/em> tasks should be addressed by programmers but offer little to no opinion on\u00a0how<\/em> those tasks should be addressed. The following are common ADTs:<\/p>\n ADTs are outlined in formal syntax through a series of algebraic declarations including a signature<\/strong> and axioms<\/strong> outlining the operations by which the ADT performs the intended actions. These operations fall into one of several common categories:<\/p>\n ADTs are, by definition,\u00a0abstract<\/em> in the sense they don’t exist by rite. Rather, ADTs are implemented as Data Structures with language-specific and use-case-specific details. For example, the Data Structures reflect the theoretical underpinnings of ADTs but implement the specifics of their operations. These objects handle data in ways designed to provide optimal performance under certain conditions. These conditions may be a programming language, a processing load, a backlog of data, or any number of other foreseen and unforeseen conditions.<\/p>\n Data Structures are often taught alongside algorithmic design and analysis in many Computer Science programs. Understanding how the design and use of certain data structures impact the efficiency of algorithmic processes is essential. Most modern programming languages afford developers many data structures to either use explicitly or to adapt for specific use cases.<\/p>\n Recommended Reading<\/strong>: Algorithms<\/em><\/a><\/p>\n Recommended Course<\/strong>: Data Structures and Algorithms: Deep Dive Using Java<\/em><\/a><\/p>\n Recursion is an eloquent concept by which functions and procedures tackle a problem by calling themselves repeatedly until a certain condition is met. Such functions and procedures are considered to be\u00a0recursive<\/em> and can be used to tackle problems such as navigating hierarchical structures like Trees. Recursive functions can also cause disaster when misused.<\/p>\n A function or procedure can be considered\u00a0recursive<\/em> if it has the following characteristics:<\/p>\n These two statements are considered the theoretical basis of recursive functions. A third condition is also present for any decent recursive function, however: the simplification of the problem at hand. Without a simplification\u2014progress towards producing a meaningful return value\u2014a recursive function will never meet its base case.<\/p>\n Recommended Reading<\/strong>: The Little Schemer<\/em><\/a><\/p>\n Recommended Course<\/strong>: Recursion, Backtracking, and Dynamic Programming in Python<\/em><\/a><\/p>\n Regular expressions are used to identify subsets of text from larger textual data. They help software validate emails, flag offensive content, and can help tidy up databases in a cinch. They can also cause disastrous results when used improperly.<\/p>\n Regular expressions evolved from the early days of Computer Science when the formal definitions of what constituted a regular<\/em> language were being defined. Concepts like context-free grammar, finite state machines, and deterministic finite automatons (DFA) all played a role in the history of regular expressions.<\/p>\n It has been said that, in solving a problem with regular expressions, one has immediately created a second problem. This statement illustrates the complexity by which many regular expressions can often embody (often by accident.)<\/p>\n Regular expressions, often referred to by the shorthand\u00a0regex,\u00a0<\/em>are available in many formats in modern programming languages. Most modern implementations reflect the Perl-style regular expressions and can trace their power to the Perl Compatible Regular Expressions (PCRE) library written in C.<\/p>\n Recommended Book<\/strong>: Regular Expressions Cookbook – O’Reilly<\/a><\/em><\/p>\n Recommended Course<\/strong>: The Complete Regular Expressions (Regex) Course for Beginners<\/a><\/em><\/p>\n Testing is an essential aspect of both the development and maintenance of software. There are many types of testing, each addressing specific concerns of a software’s operability. There is even a programming paradigm known as Test-Based Development by which developers write tests for the software before<\/em> they write the actual program. Common types of software testing include the following:<\/p>\n Each of these forms of testing is suited for specific stages during the software development process. For example, Unit Testing is used to test individual functions and methods whereas acceptance testing is more conceptual and can be used to verify a piece of software meets the requirements outlined in contracts with clients.<\/p>\n Modern programming languages almost always come with language-specific testing frameworks. For example, Python’s Recommended Reading:\u00a0<\/strong>Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation<\/em><\/a><\/p>\n Recommended Course<\/strong>: Unit Testing and Test Driven Development in Python<\/em><\/a><\/p>\n The S.O.L.I.D. principles of software development<\/a> outline a series of best practices in the field of software engineering. These include guidance for creating efficient, reusable, and interoperable code that can be easily maintained. Below is a brief summary of each primary principle of the S.O.L.I.D. framework:<\/p>\n The principles have evolved alongside the field of software development over the years. Their introduction, adoption, and successive evolution all address common problems in software design that can cause issues during the software development lifecycle.<\/p>\n The S.O.L.I.D. principles help to design modular packages, decouple essential functionalities, design for high degrees of interoperability, and leave things tidy for the next developer. Each addresses a unique concern and can be used individually without explicit concern for the others (good design there, eh?)<\/p>\n Recommended Reading<\/strong>: SOLID: Guidelines for Better Software Development<\/em><\/a><\/p>\n Recommended Course<\/strong>: SOLID Principles: Introducing Software Architecture & Design<\/a><\/em><\/p>\n Computer Science is a field in which simple concepts are used in clever ways to emulate, simulate, and create much more complex ideas. The use of 0’s and 1’s is leveraged to represent the complex interplay between numbers. Square roots, exponentiation, scientific notation, and even imaginary numbers can be represented using only 1’s and 0’s.<\/p>\n These types of numbers often require complex systems of organizing, parsing, and storing binary representations\u2014using only 1’s and 0’s.\u00a0 It isn’t necessary that every programmer understand how floating-point notation works under the hood. However, the basic understanding that floating-point numbers require more memory and are subject to odd rounding errors is very useful.<\/p>\n Computers represent data in many ways but it can all be boiled down to 1’s and 0’s eventually. While data is ultimately represented as 1’s and 0’s, there are several common intermediate methods of representing numerical data. These are derived by using different mathematical base notations. Below are the three most common forms:<\/p>\n Binary data use base-2 notation, uses the digits 0 and 1, and is most commonly associated with the 8-bit notation (a.k.a. byte<\/em>) ranging from 0-128. Octal data uses base-8 notation, uses numbers 0-7, and is much less common today\u2014used mostly for file permissions. The hexadecimal notation uses base-16 notation, introduces letters a-f into the notation, and is common among modern computing systems.<\/p>\n Recommended Reading<\/strong>: Numerical Representation in Computers<\/em><\/a><\/p>\n Recommended Course<\/strong>: Build a Modern Computer From First Principles<\/a><\/em><\/p>\n Version control is a systematic means of tracking changes to codebases over time. It’s often mistaken by beginner programmers as a simple cloud storage service\u2014which it can technically<\/em> be used for. Version control, a.k.a. source control<\/em> is much more complex than a simple backup or cloud storage option.<\/p>\n Version control helps avoid conflicting changes made by many developers to a single codebase, track changes over time such that breaking changes can be rolled back, and so much more. The Git protocol is arguably the most popular form of version control and the technology behind GitHub (though the two are separate entities.)<\/p>\n However, there are other protocols that are quite popular as well. Below is a list of common version control systems used in production code around the world:<\/p>\n Git is definitely the most popular among these protocols but doesn’t address every need a development team may face. For example, Mercurial offers a more distributed system that’s lighter weight and more portable and Subversion offers a more centralized storage approach. Each may present an ideal solution for different projects.<\/p>\n Recommended Book<\/strong>: Pro Git<\/a><\/em><\/p>\nMutable Objects<\/h3>\n
\n
Immutable Objects<\/h3>\n
\n
final<\/code> and const<\/code> are often confused with mutability. These declarations define the behavior of\u00a0references<\/em> to objects but not an object’s mutability without additional consideration.<\/p>\nControl Flow<\/h2>\n
![\"conditionals](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1999\/conditionals-control-flow-graph-illustration-alpharithms.jpg\" "\\"conditionals-control-flow-graph-illustration-alpharithms\\"")
\n
# Initial \"if\" statement checks if\r\n# if the car is started.\r\nif car_started:\r\n \r\n # If the \"is_started\" condition is True\r\n # (i.e. if the car is started) the following\r\n # code will be executed:\r\n start_driving()\r\n\r\n# The \"else\" statement provides fallback\r\n# logic should the condition not be met\r\nelse:\r\n \r\n # If the \"is_started\" condition is False\r\n # (i.e. the car is NOT started) the \r\n # Following code will be executed\r\n start_car()<\/pre>\n
\/**\r\n * A simple class demonstrating Switch statements\r\n *\/\r\npublic class ControlFlow {\r\n\r\n public static void main(String[] args) {\r\n\r\n String weekdayName = args[0];\r\n\r\n switch (weekdayName) {\r\n case \"Monday\":\r\n System.out.println(\"The First Day of the Week!\");\r\n case \"Tuesday\":\r\n System.out.println(\"The Second Day of the Week!\");\r\n case \"Wednesday\":\r\n System.out.println(\"The Third Day of the Week\");\r\n case \"Thursday\":\r\n System.out.println(\"The Fourth Day of the Week\");\r\n case \"Friday\":\r\n System.out.println(\"The Fifth Day of the Week\");\r\n case \"Saturday\":\r\n case \"Sunday\":\r\n System.out.println(\"It's the freakin' Weekend!\");\r\n default:\r\n System.out.println(\"That's not a weekday name!\");\r\n }\r\n }\r\n}\r\n\r\n\/\/ Example Usage\r\njava ControlFlow Fribsday\r\n\r\n\/\/ Resulting output\r\nThat's not a weekday name!\r\n<\/pre>\ncase<\/code> statements that test the variable weekdayName<\/code> and act accordingly. Note the “stacking” of case<\/code> statements for which the same logic is applied (Saturday and Sunday) and also the ending default<\/code> case that will catch input not addressed by other statements.<\/p>\nDesign Patterns<\/h2>\n
![\"observer](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1999\/observer-pattern-alpharithms.jpg\" "\\"observer-pattern-alpharithms\\"")
\n
\n
Object-Oriented Programming<\/h2>\n
![\"oop](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1999\/oop-design-illustration-alpharithms.jpg\" "\\"oop-design-illustration-alpharithms\\"")
\n
Abstract Data Types & Data Structures<\/h2>\n
![\"abstract](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1999\/abstract-data-types-diagram-alpharithms.jpg\" "\\"abstract-data-types-diagram-alpharithms\\"")
\n
\n
Queue<\/code> ADT can be in Python, Java, C#, or any other language\u2014but is then referred to as a Data Structure<\/strong>.<\/p>\nRecursion<\/h2>\n
![\"recursion](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1999\/recursion-illustration-diagram-alpharithms.jpg\" "\\"recursion-illustration-diagram-alpharithms\\"")
\n
Regular Expressions<\/h2>\n
![\"regex](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1999\/regex-match-anything-alpharithms.jpg\" "\\"regex-match-anything-alpharithms\\"")
Software Testing<\/h2>\n
![\"test](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1999\/test-drive-development-alpharithms.jpg\" "\\"test-drive-development-alpharithms\\"")
\n
unittest<\/code> framework is part of its standard library. This module provides functions and classes developers can use to design and automate the process of unit testing their Python code. Other languages like Java require third-party libraries like JUnit<\/code> to provide the same functionality.<\/p>\nS.O.L.I.D. Principles<\/h2>\n
![\"solid](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1999\/solid-design-principles-illustration-alpharithms.jpg\" "\\"solid-design-principles-illustration-alpharithms\\"")
\n
Numerical Representation<\/h2>\n
![\"numerical](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1999\/numerical-representation-formats-alpharithms.jpg\" "\\"numerical-representation-formats-alpharithms\\"")
\n
Version Control<\/h2>\n
![\"version](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1999\/version-control-flow-illustration-alpharithms.jpg\" "\\"version-control-flow-illustration-alpharithms\\"")
\n
![\"tabs](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1999\/tabs-vs-spaces-illustration-alpharithms.jpg\" "\\"tabs-vs-spaces-illustration-alpharithms\\"")