-
Creating Resource Dictionaries
In Windows Store Apps; you can create a Resource Dictionary; set its properties; and then use them in the app. In this video; Andy Alfred demonstrates how to create the Resource Dictionary.
-
Using Unique Locks and Condition Variables to Share Data Between Threads
In C++; you can use unique locks and condition variables to share data between threads and write multithreaded code in a platform-independent way. In this video; Steve Scott demonstrates how to use unique_lock and condition_variable.
-
Valarray operations
C++ provides a number of mathematical functions that can be applied to valarrays. In this video; Steve Scott; demonstrates valarray operations in C++.
-
Valarray Slices
In C++; you can use the slice function to index one-dimensional valarray as a two-dimensional matrix. In this video; Steve Scott demonstrates how to operate on columns of a valarray as a 4*4 matrix slice.
-
Boost - Case Conversion
In C++; the String Algorithm Library in Boost provides many case conversion functions; including a copy variant that leaves the original string intact and a non-mutable version; which modifies the input string in place. In this video; Steve Scott demonstrates how to use the Boost case conversion functions.
-
Boost - Configuring the Visual Studio IDE
In C++; you can download and set up boost libraries. In this video; Steve Scott demonstrates how to download; install; and configure boost in Microsoft Visual Studio.
-
Boost - Introduction to Dynamic Bitset
In C++; the boost dynamic bitset represents an array of bits along with a number of operations and convenient functions to manipulate them. In this video; Steve Scott demonstrates how to construct the dynamic bitset; perform logical operations on it; and compare a dynamic bitset with a standard-library bitset.
-
Boost - Introduction to Format
In C++; you can use the boost format object that takes a parameterized string and constructs an output given by repeated calls to operator%. In this video; Steve Scott demonstrates the basic usage of the boost format object.
-
Boost - Introduction to String Algorithms
In C++; there are different string algorithms. In this video; Steve Scott discusses the different string algorithms.
-
Boost - String Classification
In C++; the Boost string processing makes use of the classifiers. In this video; Steve Scott demonstrates how to use the classifier functions in Boost string.
-
Boost - String Erase and Replace
In C++; boost provides a number of ways to erase and replace substrings or character sequences within a string. In this video; Steve Scott demonstrates how to use the erase and replace strings.
-
Boost - String Find Algorithms
The Boost string algorithm library in C++ contains a number of find algorithms. In this video; Steve Scott demonstrates how to use the find algorithm in different ways.
-
Boost - String Iterators
In C++; the String Algorithm Library in Boost provides many ways to iterate over a string. In this video; Steve Scott demonstrates two methods for iterating over a string.
-
Boost - String Predicates
In C++; you can use the predicate functions from the string algorithm library in boost to check particular conditions in which a substring is contained within another string. In this video; Steve Scott demonstrates four predicate functions and how to split and join strings using boost.
-
Boost - String Split and Join
In C++; you can use split and join which are the two most common string processing functions. In this video; Steve Scott demonstrates how to split and join strings.
-
Boost - Trimming Strings
In C++; you can use the string algorithm library in boost that provides a number of ways to trim strings. In this video; Steve Scott demonstrates how to use the trim functions in boost.
-
Boost - Using Any
The boost any library can be thought of as an object-oriented type-safe alternative to void. In this video; Steve Scott demonstrates the basic use of the boost any library.
-
Boost - Using BOOST_FOREACH
The BOOST_FOREACH macro provides a convenient way to iterate over collections such as arrays; containers; and strings in C++. In this video; Steve Scott demonstrates how to use the BOOST_FOREACH.
-
Boost - Using Tabulation and Manipulators
In C++; you can use the boost format library that provides a number of functions for formatting output. In this video; Steve Scott demonstrates tabulation and grouping manipulators to format output.
-
Boost - Using the Bimap
In C++; you can use bimap container to represent a bijective relationship between two sets. In this video; Steve Scott demonstrates the basic use and behavior of the boost library bimap.
-
Boost - Using the Circular Buffer
The Boost circular buffer is a C++ container that overwrites its elements when full. In this video; Steve Scott demonstrates how to use the circular buffer and highlight its characteristic behavior.
-
Boost - Using The Dynamic Bitset
In C++; the boost dynamic bitset provides a number of ways to manipulate and compare arrays of bits. In this video; Steve Scott demonstrates ways to set and test individual bits and some other important functions in the boost dynamic bitset library.
-
Boost - Using the Lexical Cast
Boost provides a function template called lexical cast; which gives us a consistent way of casting back and forth between numbers and strings. In this video; Steve Scott demonstrates some basic conversions using lexical cast.
-
Boost - Using the Tokenizer
In C++; you can use boost tokenizer that provides a container to represent a set of tokens from a given sequence. In this video; Steve Scott demonstrates examples of tokenizing strings using default method and custom delimiters.
-
Boost - Using Tokenizer Separators
In C++; you can use the tokenizer function called separators that processes string sequence as tokens. In this video; Steve Scott demonstrates escape list separator and offset separator.
-
Boost - Using Variant
In C++; you can use the boost variant class; which is a safe; generic; stack-based discriminated union container. Boost variant provides efficient and easy-to-use variant types based upon discriminated unions. In this video; Steve Scott demonstrates the basic usage of the boost variant object.
-
Boost - UUID
In C++; you can use the boost library to generate universally unique identifiers or UUID. In this video; Steve Scott demonstrates random UUID generator and string generator.
-
Boost Date/Time – Introduction to Posix Time
In C++ programming; you can access and modify the posix time representation system by using Boost posix time library. In this video; Steve Scott demonstrates how to use the Boost posix time library functions to access and modify the posix time.
-
Boost Date/Time – Introduction to the Gregorian Calendar
In C++; you can use the Boost library to access and modify the Gregorian calendar. In this video; Steve Scott demonstrates how to use the Boost library functions to access and modify the Gregorian calendar.
-
Boost Numeric Conversion – Checking Numeric Bounds
The boost numeric bounds provides a consistent interface for retrieving the maximum value; the minimum value; and the minimum positive value for numeric types. In this video; Steve Scott demonstrates how to use numeric bounds.
-
Boost Numeric Conversion – Using Numeric Cast
Boost provides a function template to manage numeric conversions. In this video; Steve Scott demonstrates some basic numeric conversions in C++.
-
Boost Numeric Conversion – Using the Numeric Converter
In C++; Boost provides the converter function object; which lets you perform conversions between numeric types that you specify. In this video; Steve Scott demonstrates a conversion from double to int by using the numeric converter.
-
Enumeration Classes
C++ offers two types of enumerations; the old style C or C++98 style enumerations and the new enumeration classes. In this video; Steve Scott demonstrates the differences between the two types of enumeration classes.
-
Introduction to Boost
Boost is a set of libraries for the C++ programming language. In this video; Steve Scott discusses background information and overview of the Boost libraries.
-
Introduction to Insert Iterators
In C++; you can use insert iterators as a safe way to add elements to a container without fear of memory corruption and overflow. In this video; Steve Scott will demonstrate insert iterators through the use of the helper functions back_inserter and front_inserter.
-
Introduction to Iterators Using Find
In C++; you can use iterators to combine algorithms and data containers in the standard library. In this video; Steve Scott demonstrates use of iterators using find function on a vector.
-
Introduction to Iterators Using Sort
In C++; you can use the standard library sort function to take iterators as arguments to specify the range of elements to sort. In this video; Steve Scott will demonstrate how to sort a subsequence of elements in a vector using iterators.
-
Introduction to Lambda Expressions
In C++; you can use lambda functions to easily express many design patterns. In this video; Steve Scott demonstrates how to use syntax; structure; and terminology of lambda expressions.
-
Introduction to Smart Pointers
C++ 11 offers smart pointers to help reduce memory bugs by providing some automatic memory management and bound safety. In this video; Steve Scott discusses a few considerations governing the use of smart pointers.
-
Introduction to Static Assertions and Type Traits
In C++; you can use static_assert and type_traits at compile time to enforce type safety while writing generic code to eliminate errors at run time. In this video; Steve Scott demonstrates how to combine type_traits and static_assert to validate code at compile time.
-
Introduction to Threads
The C++ standard library thread allows users to write platform-independent multithreaded code. In this video; Steve Scott demonstrates the three ways to construct and execute threads.
-
Introduction to Valarray
In C++; you can use the Standard-Library valarray that represents an array of values to apply mathematical operators. In this video; Steve Scott demonstrates various ways to construct valarrays and perform some basic arithmetic on them.
-
Lambda Expressions - Using the Capture List
The C++ lambda expressions allow users to change the capture list in the lambda syntax. In this video; Steve Scott explains how to use the capture list to give a lambda expression access to local variables by reference and by value.
-
Lambda Expressions - Using the For Each Helper Function
C++ allows users to use the for_each function of the Standard Library with lambda expressions. In this video; Steve Scott demonstrates how to use the for_each loop with lambda expressions and compare it with the conventional C++ for_each loop.
-
Lambda Expressions - Using the Standard Library Sort
In C++; you can use lambda expressions with several Standard Library functions. In this video; Steve Scott explains how to use lambda expressions with the sort function.
-
Numeric Type Literals
In C++; you can use different prefixes; infixes; and suffixes to specify how the compiler should interpret a numeric literal in your code. In this video; Steve Scott explains the various numeric type literals that can used in C++ and how they are interpreted by the compiler.
-
Overloading Operators on an Enumeration Class
In C++; you can overload operators that act on your enum class for greater expressive control over enumerations. In this video; Steve Scott demonstrates an example of overloading a unary operator on an enum class.
-
Primary Type Traits
In C++; you can access information about types at compile-time. This is an important tool in ensuring type-safe code within generic programming structures such as function or class templates. In this video; Steve Scott demonstrates the primary type traits available in C++ as well as demonstrating a few examples.
-
Smart Pointers - Using the Shared Pointer
The C++ shared pointer is a smart pointer that allows you to manage shared ownership of memory through pointers. In this video; Steve Scott demonstrates the basic use and syntax of the standard library shared pointer.
-
Smart Pointers - Using the Unique Pointer
The C++ unique pointer is a smart pointer; which points to an object uniquely so that no other pointer can delete the object. In this video; Steve Scott demonstrates the basic use and syntax of the standard library unique pointer.
-
Smart Pointers - Using the Weak Pointer
The C++ weak pointer is a smart pointer that points to an existing shared pointer; but it does not increase the reference count of the shared pointer. In this video; Steve Scott demonstrates the basic use and syntax of the standard library weak pointer.
-
Specifying Return Type Using Suffix Notation
In C++; you can now specify return types in suffix form in contrast to the conventional prefix form. In this video; Steve Scott demonstrates a few scenarios with the suffix notation.
-
The 11 Auto Keyword
In C++; the auto specifier tells the compiler to deduce the type of the variable from the expression and it helps to avoid verbose and long type names. In this video; Steve Scott discusses the C++11 auto keyword.
-
The 11 Constant Expression
In C++11; you can use the constexpr that allows for more versatile constants. In this video; Steve Scott demonstrates the basics for getting started with constexpr.
-
The 11 Nullptr Literal
The C++11 standard introduced the new nullptr literal to replace the old convention of using 0 or NULL. In this video; Steve Scott discusses the differences between the old and new ways of using pointers and explains the benefits of nullptr in modern C++ code.
-
Threads - Accessing Properties of stl::this_thread
Using the standard library thread in C++; you can access this_thread class which can be called to get; yield; or make thread sleep for a time interval. In this video; Steve Scott demonstrates the this_thread public; member functions through the use of a threaded lambda expression.
-
Threads - Passing Arguments
In C++; you can pass data or memory locations to a thread by passing an argument. In this video; Steve Scott demonstrates how to pass a string reference to different threads.
-
Threads - Returning Values
In C++; you can share information with threads by passing a pointer to a memory location. In this video; Steve Scott demonstrates how to pass and return a string from a thread by using a pointer.
-
Threads - Using Async
Using the standard library async function in C++; you can call a function asynchronously. In this video; Steve Scott demonstrates how to call four functions asynchronously and use future to get their corresponding return values.
-
Threads - Using Atomic Variables
In C++; you can use atomic variables to automatically synchronize modifications from multiple threads at the same time. In this video; Steve Scott demonstrates how to use an atomic variable which is incremented by three concurrent threads.
-
Threads - Using Future and Promise
In C++; the standard library promise and future help in sharing information between threads. In this video; Steve Scott demonstrates how to use future and promise.
-
Threads - Using Packaged Task
Using the standard library packaged task in C++; you can call a function asynchronously. In this video; Steve Scott demonstrates how to make a function asynchronous using the standard library packaged_task with a corresponding future to get the return value from the function.
-
Type Traits - Composite Type Category
In C++; the composite type category of type_traits tells you whether a type is fundamental or composite; along with the useful ways of distinguishing the types. In this video; Steve Scott explains the composite type options.
-
Type Traits - Property Queries
The C++ Type Traits consists of three property queries: alignment_of; extent; and rank. In this video; Steve Scott demonstrates how to use each property query in C++.
-
Type Traits - Type Features
In C++; you can use the type features to perform the compile-time checks for constructors; destructors; and copy or moved assignments. In this video; Steve Scott demonstrates various ‘type features’ in C++.
-
Type Traits - Type Properties
In C++; the type property subset of type traits provides several functions to check the basic characteristics such as whether a value is abstract; polymorphic; constant etc. In this video; Steve Scott demonstrates type properties using some examples.
-
Type Traits – Type Relationships
In C++; the type relationship subset of type_traits provides you a way of comparing two objects at compile time. In this video; Steve Scott explains the three type relationship functions available in C++.
-
Using bind for Partial Evaluation
In C++; you can use bind to partially evaluate a function. In this video; Steve Scott demonstrates how to fix arguments to a function and call that function with the remaining arguments.
-
Using Bit Fields
In C++; bit fields allow users to specify member variables with the particular number of bits. In this video; Steve Scott demonstrates the important aspects of bit fields in terms of memory use and alignment.
-
Using Initializer Lists
In C++; the initializer lists provide a convenient way to construct or initialize many standard library containers. In this video; Steve Scott demonstrates how to use them; pass them through functions; and create constructors that use them.
-
Using Iterators to Copy and Move
In C++; you can use a number of helper functions to efficiently move elements from one container to another using iterators. In this video; Steve Scott demonstrates how to move and copy elements between containers.
-
Using Mutexes to Synchronize Threads
In C++; you need to include the mutex header from the standard library and then declare the mutexes. In this video; Steve Scott demonstrates how to use mutexes to synchronize threads.
-
Using Nothrow New to Suppress Allocation Exceptions
In C++; you can handle errors directly by suppressing the exception. In this video; Steve Scott demonstrates how to use nothrow with new and delete to suppress the exception handling.
-
Using the mem_fn Function Adapter
In C++; you can use the standard library function adapter mem_fn function to call an object's member function as a regular function; i.e. as a non-member function. In this video; Steve Scott demonstrates the use of mem_fn through the use of the standard library transform function.
-
Using the Standard Library Bitset
In C++; the Standard Library bitset represents the sequence of bits of a given length and provides the usual bitwise operators along with a number of convenient constructors. In this video; Steve Scott demonstrates a variety of constructors in bitwise operations using bitsets.
-
Using the Standard Library Pair
In C++; pair provides a consistent way to access; manipulate; and return variables that come up in pairs. In this video; Steve Scott demonstrates how to use the Standard Library pair.
-
Using the Standard Library Unordered Map
The C++ Standard Library implements a type of associative array called the unordered_map. In this video; Steve Scott demonstrates how to access; insert; and remove elements in the unordered_map.
-
Using the Standard-Library Array Container
In C++; the array container provides several standard library functions for added convenience and for safety. In this video; Steve Scott explains how to use the standard library array.
-
Using the Standard-Library Double Ended Queue
In C++; you can create container for adding or removing elements from the front or back using a double-ended queue called deque. In this video; Steve Scott demonstrates the basic use and behavior of the standard library deque.
-
Using the Standard-Library Multimap
In C++; you can use the Standard-Library multimap which is a container of key value pairs which allows duplicates of elements if associated values are different. In this video; Steve Scott demonstrates the basic use and functionality of the Standard-Library multimap.
-
Using the Standard-Library Multiset
In C++; we use the Standard-Library multiset which is a variation of the Standard-Library set. A multiset retrieves elements' values based on their associated key value. In this video; Steve Scott demonstrates the difference between a set and a multiset and the usage of both.
-
Using the Standard-Library Priority Queue
In C++; you can use the Standard-Library priority_queue which always returns the top element as the greatest element. In this video; Steve Scott demonstrates how to use a priority_queue.
-
Using the Standard-Library Stringstream
The standard-library stringstream operates on an internal string-like buffer in C++ 2014. In this video; Steve Scott will demonstrate the basic syntax and usage of the standard-library stringstream.
-
Using the Standard-Library Unordered Set
In C++; you can use the standard library unordered_set to store unique objects. In this video; Steve Scott demonstrates how to use the unordered set and describes a few of its properties.
-
Using Type Information at Run-time
In C++; you can use a number of utilities and helper functions to access and use type information at run-time. In this video; Steve Scott demonstrates how to use the typeid function along with the underlying type_index of a variable.
-
Boost - Using Variant Visitor
The variant class is a type-safe; an object-oriented version of a C style union. In this video; Steve Scott demonstrates an example of using a static_visitor on a variant type.
-
Changes to Lambda Expressions
Using lambda expressions in C++14; you can allow variables in the capture list to be initialized and set arguments to lambda expressions to be auto declared. In this video; Steve Scott demonstrate the changes to lambda expressions in the C++14 standard.
-
Function Return Type Deduction
You can use the auto return type for a regular function in C++14. In this video; Steve Scott demonstrates how to use the return type function.
-
Introduction to the Standard
C++14 is the next update to the ISO/IEC C++ standard. In this video; Steve Scott discusses the important updates in C++14.
-
Updated Constant Expressions
In C++11; you could use the constant expressions but their usage was limited. In C++14 the rules for constant expressions are relaxed. In this video; Steve Scott demonstrate some example constant expressions that will work in a C++14 standard compiler.
-
Updated Literals
In C++; you can use many predefined literals to specify a value. Now in C++14 we get additional standard literals. In this video; Steve Scott demonstrate some of new standard literals that will be available in C++14.
-
Creating a Lock Screen App
In Windows Store apps; you can set up and customize a lock screen to lock your device. A lock screen app conveys information and protects your computer against unauthorized use. In this video; Andy Alfred demonstrates how to create a lock screen app.
-
Debugging a Background Task using Visual Studio 2013
In C#; you can debug a background task by using the tools provided in Visual Studio 2013. In this video; Andy Alfred demonstrates how to debug a background task.
-
Deploying an App for the Enterprise
Using C#; you can deploy a Windows Store app in an enterprise environment. In this video; Andy Alfred explains how to deploy a Windows Store app for the enterprise.
-
Using the Canvas Layout Control
In Windows Store applications; you can use the Canvas Layout Control and explicitly position its elements by providing coordinates. In this video; Andy Alfred demonstrates how to use the Canvas Layout Control.
-
Using the WebAuthenticationBroker in Single Sign on (sso) Mode
In C#; you can use WebAuthenticationBroker in single sign on mode to leverage the single sign on to an online service provider across multiple applications. In this video; Andy Alfred demonstrates how to use the WebAuthenticationBroker in single sign on (sso) mode.
-
Using the WebAuthenticationBroker to connect to an online identity provider
In Windows Store apps; you can use the WebAuthenticationBroker class to connect your app with an online service provider. In this video; Andy Alfred demonstrates how to use the WebAuthenticationBroker class to connect the app with an online service provider.
-
Enabling Zooming and Scrolling on Elements
In Windows Store apps; you can use ScrollViewer control to enable zooming and scrolling on elements using C#. In this video; Andy Alfred demonstrates how to enable zooming and scrolling on certain UI elements in xaml files.
-
Getting Familiar with Flyout Controls
In C#; Flyout controls are used to create popups that display a message or other control elements. In this video; Andy Alfred discusses Flyout controls to create interface elements that pop up and respond to user interaction.
-
Getting Familiar with Lock Screen Apps
In Windows Store apps; you can set up a lock screen to lock your device. A lock screen is a user-customizable surface that conveys information and protects your computer against unauthorized use. In this video; Andy Alfred discusses the lock screen apps.
-
Getting Started with Visual Studio 2013 to Create Windows Store Apps
In C#; you can create apps by using Visual Studio 2013. In this video; Andy Alfred displays the basics of the Visual Studio 2013 development environment which is used to create a Windows Store App.
-
How the WebAuthenticationBroker works
The WebAuthenticationBroker class in Windows Store apps provides an easy and secure way for developers to integrate apps with the services provided by an online service provider. In this video; Andy Alfred explains about the WebAuthenticationBroker class.
-
How Web Authentication Broker in Single Sign on mode
In Windows Store app; you can use the WebAuthenticationBroker class in a Single Sign-On mode. In this video; Andy Alfred demonstrates how to use WebAuthenticationBroker class in a Single Sign-On mode.
-
Requesting a Lock Screen Presence from a Windows Store App
In C#; you can set up an app to be eligible to be a Lock Screen app and set up the request to allow the user to allow or deny the Lock Screen presence. In this video; Andy Alfred demonstrates how to add functionality to an app in order to request a Lock Screen presence from a Windows Store app.
-
The Hub App Template
You can design and create an application based on the Hub App template in Visual Studio. In this video; Andy Alfred demonstrates the inner workings and functionality provided by the Hub App template.
-
The Suspending Event and the SuspensionManager Class
While developing Windows Store apps; you can use the SuspensionManager class to retrieve the app state if the app is suspended or terminated. In this video; Andy Alfred explains about the SuspensionManager class.
-
Understanding Certification and Submission
To make your app publicly listed and available in the Windows Store; you need to understand and follow the submission and certification processes. In this video; Andy Alfred discusses how to get an app ready for submission.
-
Using a Background Task Part 1 (Creating the Task)
While developing Windows Store apps by using C#; you can set up a background task that performs useful activities even when the application is not in the foreground. In this video; Andy Alfred demonstrates how to create a background task.
-
Using a Background Task Part 2 (Registering the Task)
In C#; you can set background task to perform some useful work when the app is not in the foreground. In this video; Andy Alfred demonstrates how to register a background task.
-
Using SuspensionManager to Save and Restore App State
While developing Windows apps using C#; you can use the SuspensionManager class to save and restore your app state. In this video; Andy Alfred explains how to use the SuspensionManager class.
-
Windows Store App Activation
In C#; you can use different activations to activate Windows Store apps. In this video; Andy Alfred demonstrates how to activate Windows Store apps using some different ways.
-
Windows Store App Certification Requirements
You can refer to the Microsoft Developer Network site for the document with details on requirement for Windows Store app certification. In this video; Andy Alfred discusses the current Windows Store app certification requirements.
-
Working with PLM Events in Windows Store Apps
In C#; you can use process lifetime management events for your Windows Store applications. In this video; Andy Alfred demonstrates how to work with PLM Events in Windows Store apps.
-
Adding and Removing Array Elements in Objective C
In Objective-C; you can create an array; add data to it or remove data from it. In this video; Andy Alfred demonstrates how to add and remove data from arrays in Objective-C.
-
Adding and Removing Data From a Dictionary in
Objective-C supports associative arrays and allows you to add and remove key-value pairs. In this video; Andy Alfred discusses how to add and remove key-value pairs in a dictionary.
-
Checking File Attributes Using
In Objective-C; we can get more information about the attributes of a file. In this video; Andy Alfred demonstrates how to get the information about the attributes of a file by using a Objective-C program.
-
Conforming to a Protocol in
In Objective-C; when you create a class or use an existing class that needs to conform to some protocol; you need to provide implementations of the methods named in the protocol. In this video; Andy Alfred explains how to conform to a protocol in Objective-C programs.
-
Converting Between Strings and Numbers in
Objective-C provides several methods to convert integers to strings and vice-versa. In this video; Andy Alfred explains some methods to make the transition between strings and numbers seamless.
-
Creating Class Level and Instance Level Methods in
In Objective C; you can call class-level methods by just using the class name itself; whereas for instance-level methods; you need to set an instance in place. In this video; Andy Alfred explains how to create both class and instance-level methods in Objective-C programs.
-
Creating Custom Classes in
In Objective-C; you can create your own custom classes to meet your requirements. In this video; Andy Alfred demonstrates how to create custom classes in Objective-C.
-
Creating Custom Initializers in
In Objective-C; you can use alloc and init methods provided by NSObject to allocate and initialize objects. In this video; Andy Alfred demonstrates how to create and set up the custom initializers in Objective-C.
-
Creating Dictionaries in
In Objective-C; you can use an associative array and hash by using the data structure called dictionary. In this video; Andy Alfred demonstrates how to create a dictionary in Objective-C.
-
Reading Arguments Passed to an Command Line Tool
In Objective-C; arguments can be read and used from within the program at runtime. In this video; Andy Alfred discusses how to read arguments passed to a program from Objective-C.
-
Reading From a File in
In Objective-C; you can locate; open; and read files from disk. In this video; Andy Alfred demonstrates how to read files by using Objective-C programs.
-
Reading Values From Property Lists in
In Objective-C you need to know how to access and read stored data in a property list file at runtime. In this video; Andy Alfred discusses how to make use of property list files in Objective-C programs.
-
Setting up Timers in
Objective-C provides the NSTimer class; which allows users to set up timers that can call a method every x seconds once or repeatedly; based on a program's need. In this video; Andy Alfred explains how to set up simple timers in an Objective-C program.
-
Sorting a Dictionary in
In Objective-C the key-value pairs in a dictionary are unordered and you may need to access these key-value pairs in an ordered method. In this video; Andy Alfred discusses how to sort the data contained in a dictionary.
-
Using Common Mathematical Functions in
Objective-C is a subset of C and therefore; you can directly use the C-style built-in math functions in your programs. In this video; Andy Alfred explains how to use some common built-in math functions in Objective-C programs.
-
Using Constants in
In Objective-C; you can create constants and use them repeatedly throughout your program. In this video; Andy Alfred explains the two ways to create and use constants in Objective-C programs.
-
Using Enumerated Types in
In Objective-C; enumerator types allow us to define a type in the program that can take only a defined set of values. In this video; Andy Alfred explains how to create enumerator types.
-
Using Fast Enumeration in
Objective-C provides a convenient way to iterate through elements in an array with the fast enumeration. In this video; Andy Alfred demonstrates how use fast enumeration in an Objective-C program.
-
Using the For Loop in
The "for" loop in Objective-C; provides an easy-to-use method for iterating through an array with a counter in the programs. In this video; Andy Alfred explains how to use the "for" loop.
-
Using the 'if' Conditional
Similar to all programming languages; in Objective-C; the "if" conditional allows users to execute a block of code only if a certain expression evaluates to true and ignore it otherwise. In this video; Andy Alfred demonstrates how to use the "if" statement.
-
Using the Switch Statement in
Objective-C provides the switch - case block as an alternative to the cascading if - else statements; as they are simpler to create and easier to read when comparing an expression to multiple scenarios. In this video; Andy Alfred explains how to create a switch - case block.
-
Using the While Loop in
In Objective-C; the while loop executes a block of code repetitively until a certain expression evaluates to false; at which point the while loop terminates. In this video; Andy Alfred explains how to use the while loop.
-
Working with Common Built-in String Functions
Objective-C provides many built-in functions that can be used to manipulate and work with strings. In this video; Andy Alfred discusses how to use built-in string functions.
-
Working with Subclasses in
In Objective-C; Subclassing allows you to create classes based on other classes; and to inherit properties and methods from the super class. In this video; Andy Alfred demonstrates how to create a subclass and inherit the super class data in Objective-C.
-
Writing Data to Property List Files in
In Objective-C; you can create and add information to a property list file to store Objective-C data. In this video; Andy Alfred discusses how to open and write data to a property list file by using Objective-C.
-
Writing to a File Using
In Objective-C; you can locate; open; and write to files. In this video; Andy Alfred demonstrates how to locate; open; and write to files in Objective-C.
-
Creating a Protocol in
In Objective-C; protocols allow you to create a messaging contract. In this video; Andy Alfred demonstrates how to create custom protocols in Objective-C.
-
Agile Software Development
SOLID principles are guidelines that can be applied while working on software and when developing in an object-oriented environment; facilitating the Agile process. In this video; Sidney Andrews demonstrates how Agile software development is a group of methods whereby collaboration between self-organizing; cross-functional teams results in consistent requirements and solutions.
-
Applying LSP in C#
In SOLID; you can reuse code when creating base classes or when having multiple items with similar behavior in using interfaces. In this video; Sidney Andrews uses the Liskov Substitution Principle to write C# code that is more flexible and easier to read.
-
Applying The Dependency Inversion Principle
In SOLID; the Dependency Inversion Principle (DIP) refers to a specific form of decoupling software modules. In this video; Sidney Andrews demonstrates how to apply the DIP to dependencies in a transaction class in an application.
-
Applying The Interface Segregation Principle
In SOLID; the Interface Segregation Principle states that many client specific interfaces are better than one general purpose interface. In this video; Sidney Andrews demonstrates how to apply the Interface Segregation Principle to a payment processor in an application.
-
Applying The Liskov Substitution Principle
In SOLID; the Liskov Substitution Principle states that objects within a program should be replaceable with instances of their subtypes without altering the correctness of that program. In this video; Sidney Andrews demonstrates how to apply the Liskov Substitution Principle when designing an application.
-
Applying The Open Closed Principle
The Open Closed Principle in SOLID is one of the five principles of object oriented programming and design; and states that software entities should be open for extension but closed for modification. In this video; Sidney Andrews demonstrates how to apply the Open Closed Principle when developing an application.
-
Applying The Single Responsibility Principle
SOLID states that the first principle of computer programming is The Single Responsibility Principle; which states that a class should only have a single responsibility. In this video; Sidney Andrews demonstrates how to apply the Single Responsibility Principle when designing an application.
-
Cohesion and Coupling
In SOLID; interface segregation with dependency inversion helps to achieve high cohesiveness while reducing tight coupling. In this video; Sidney Andrews uses a coupling example to show tightly coupled classes that do not work together.
-
Constructor Injection in C#
In SOLID; you can use a constructor injection in a C# application to add dependencies. In this video; Sidney Andrews uses a constructor to inject a dependency resulting in very few code changes to methods applied to each instance.
-
Dependency Injection and Dependency Inversion
In SOLID; dependency injection is the most popular implementation of the Dependency Inversion Principle. In this video; Sidney Andrews uses the Open Closed Principle to discuss how dependency injection helps to maintain SOLID principles.
-
DIP and The Open Closed Principle
In SOLID; there is a relationship between the Open Closed Principle and the Dependency Inversion Principle (DIP). In this video; Sidney Andrews uses the Open Closed Principle to extend the functionality of an application without modifying the existing interface or method.
-
Examples of Design in C#
There are a number of ways you can implement a SOLID design in C#. In this video; Sidney Andrews demonstrates how to create a SOLID design in C# focussing on object-oriented patterns.
-
Implementing Dependency Injection in C#
In SOLID; you can use dependency injection to enhance your C# application. In this video; Sidney Andrews uses the Unity dependency injection framework to inject dependencies through properties; methods; and constructors.
-
Implementing ISP in C#
In SOLID; it is possible to execute the Interface Segregation Principle (ISP) in Visual Studio and C# using interface inheritance. In this video; Sidney Andrews demonstrates how to implement an inheritance interface in C#.
-
Implementing SRP in C# Class Design
SOLID C# class design demands implementation of the single responsibility principle (SRP). In this video; Sidney Andrews demonstrates high-level analytical and Visual Studio tools that ensure C# class SRP compliance; before creating a reusable; single-responsibility class complementing the base class.
-
Implementing The DIP in C#
In SOLID; the Dependency Inversion Principle (DIP) gives you a lot of flexibility on how you design your C# application. In this video; Sidney Andrews uses the DIP to fulfill dependency requirements specified in a constructor.
-
Introduction to The Dependency Inversion Principle
In SOLID; you can test and change application modules by using the Dependency Inversion Principle (DIP). In this video; Sidney Andrews demonstrates how to manage dependencies in an application.
-
Problems with Poor SRP Class Design
In SOLID; you should be able to deal with poor Single Responsibility Principle class design. There are a limitless amount of things you can do when you're designing for Single Responsibility. In this video; Sidney Andrews demonstrates what can happen if you have multiple responsibilities within a class.
-
Problems with Tight Coupling
Tight coupling can present a couple of problems in SOLID. In this video; Sidney Andrews uses a tight coupling example to illustrate how an issue with one class affects other classes in an application.
-
Property Injection in C#
In SOLID; you can use a property injection in a C# application. In this video; Sidney Andrews uses a property to set different values in a method and modify it.
-
Introduction to The Interface Segregation Principle
In SOLID; there are a number of ways you can avoid contract bloat in your applications. In this video; Sidney Andrews uses the Interface Segregation Principle to split or inherit interfaces to ensure that applications only use methods or properties of an interface that they need.
-
Introduction to The Liskov Substitution Principle
The Liskov substitution principle; referenced in the SOLID acronym; refers to the ability of a subtype to substitute for the type from which it’s derived. In this video; Sidney Andrews demonstrates the principle; explaining that it’s supported by object-oriented languages but that it’s important not to violate the principle through faulty class implementation.
-
Introduction to The Open Closed Principle
SOLID C# class extensibility demands adherence to the open/closed principle (OCP). In this video; Sidney Andrews demonstrates how C# classes open for extension but closed for modification enable the reliable; maintainable extensibility of object-oriented programming constructs.
-
Introduction to The Single Responsibility Principle
The Single Responsibility Principle is a SOLID standard that recommends you design modules in the simplest way possible. The fundamental idea is that you have different components in the application all responsible for a single thing. In this video; Sidney Andrews demonstrates how the Single Responsibility Principle functions.
-
ISP Through Delegation
In SOLID; it is possible to change code that could not usually be altered through delegation by using the Interface Segregation Principle (ISP) with an adapter pattern. In this video; Sidney Andrews demonstrates how to implement an adapter interface with the ISP.
-
ISP Through Inheritance
In SOLID; when implementing the Interface Segregation Principle (ISP); the best way is to use interface inheritance which gives you a fresh start that is easy to read and service. In this video; Sidney Andrews demonstrates how to implement an inheritance interface with the ISP.
-
Method Injection in C#
In SOLID; you can use method injections in your C# application. In this video; Sidney Andrews uses a method parameter injection to specify dependencies that are unique to a particular method.
-
Object Oriented Design
SOLID is a mnemonic acronym that stands for the five basic principles of Object-Oriented Programming and Design. In this video; Sidney Andrews introduces the SOLID mnemonic and talks about some of the benefits of using this paradigm.
-
OCP and Abstraction
In the acronym SOLID; the “O” stands for the open/closed principle (OCP). In this video; Sidney Andrews demonstrates how this principal applies when creating public classes that inherit specific functionality from an abstract base class in C#.
-
OCP and Interfaces
SOLID C# interfaces ensure compliance with the open/closed principle (OCP) by guaranteeing that their extensible implementation classes meet required specifications. In this video; Sidney Andrews demonstrates how designing from the interface renders code closed for modification from the outset.
-
OCP Conventions in OOD
The open/closed principle that’s referenced in SOLID is implemented through various behaviors and conventions. In this video; Sidney Andrews demonstrates how inheritance; polymorphism; interfaces; encapsulation; and information hiding support the open/closed principle in C#.
-
Planning for a Application
It is important that you follow the SOLID principles when planning your application and deciding on how dependencies should be implemented. In this video; Sidney Andrews uses an Inversion of Control (IoC) container to discuss managing dependencies throughout the application.
-
Problems with Interface Bloat
In SOLID; common problems exist when developing applications; one of which is interface bloat. In this video; Sidney Andrews demonstrates how to implement a new interface to avoid bloat caused by a large amount of implemented methods.
-
Problems with Poor OOD
SOLID principles in Object-Oriented Development are used to solve code smells; or problems; that you could face with Object-Oriented Design. In this video; Sidney Andrews demonstrates the problems you could have with Object-Oriented Design; and the methodology and principles that can help you stay on the right track.
-
Benefits
SOLID provides you with many benefits when working with Object-Oriented Design. Many of the benefits from SOLID are directly related and almost completely linked to the benefits of Object-Oriented Design. In this video; Sidney Andrews demonstrates some of the benefits of following a SOLID pattern.
-
SRP Benefits
In SOLID; the largest benefit with Single Responsibility is maximum code reuse. In this video; Sidney Andrews demonstrates the advantages of the Single Responsibility Principle (SRP).
-
Understanding Abstractions and The DIP
In SOLID; you have the ability to invert control and manage dependencies. In this video; Sidney Andrews demonstrates how to work with Abstraction and the Substitution Principle; and how they relate to the Dependency Inversion Principle (DIP).
-
Understanding Closure and The OCP
According to the open/closed principle; which is one of the principles referenced by the SOLID acronym; application code should be open for extensibility but closed for modification. In this video; Sidney Andrews demonstrates why it’s important to extend existing code rather than modifying it in order to prevent errors and unnecessary work.
-
Understanding Dependencies
In SOLID; understanding the basics on how to create dependencies is helpful when managing and inverting dependencies. In this video; Sidney Andrews demonstrates how to create dependencies and the variables and classes involved.
-
Understanding Interfaces
In SOLID; you can use interfaces to represent classes. In this video; Sidney Andrews uses the Interface Segregation Principle to create a new interface for Method C and prevent a change in Class 1.
-
Understanding Inversion and The DIP
In SOLID; you can use the Dependency Inversion Principle (DIP) to manage your dependencies. In this video; Sidney Andrews uses a method injection to support dependency inversion.
-
Understanding Subtyping and Behavior
In SOLID; it is important that you understand subtyping and the behavior of inheritance within C#. In this video; Sidney Andrews uses subtyping to discuss the flexibility of functionality when designing abstract and base classes.
-
Utilizing The OCP in C#
In C#; certain language constructs indicate that you may be violating the open/closed principle of SOLID. In this video; Sidney Andrews demonstrates situations in which it’s preferable to replace these constructs by extending classes to create subtypes.
-
Violating the DIP in C#
In SOLID; a dependency can cause you to violate the Dependency Inversion Principle (DIP) in your C# application. In this video; Sidney Andrews uses fakes to inject fake dependencies in a unit test.
-
Violating the LSP in C#
In SOLID; your implementation of code in C# can violate the Liskov Substitution Principle (LSP). In this video; Sidney Andrews uses the override command to overrule the base class and throw application exceptions thereby violating the LSP.
-
Violating the OCP in C#
SOLID C# class extensibility; by way of the open/closed principle (OCP); is easily violated. In this video; Sidney Andrews demonstrates how the violation of a C# program by multiple modification types can be used to reinforce extensibility through SOLID OCP.
-
Violating the SRP in C#
In SOLID; there are ways in which you can infringe on the standards of the Single Responsibility Principle. In this video; Sidney Andrews demonstrates the consequences of violating the Single Responsibility Principle in C#.
-
Mobile Form Elements - Select Menus
In jQuery Mobile; you can modify different form elements. In this video; Charles Robinson demonstrates how to configure select menus drop-down.
-
Creating Arrays in
Objective-C provides a number of ways to create arrays in the language. In this video; Andy Alfred demonstrates how to create arrays by using Objective-C.
-
Creating Strings in
There are a number of different ways to create strings in Objective-C. In this video; Andy Alfred demonstrates how to create strings in different ways.
-
Introducing
SOLID is a set of principles for Object-Oriented Design that can help you avoid may of the code smells that can happen in an object-oriented application. In this video; Sidney Andrews demonstrates the five principles of SOLID and what they allow you to do.
-
Understanding Inheritance
In SOLID; you can use the concept of inheritance to provide instant reusability that allows you to extend classes in different ways. In this video; Sidney Andrews demonstrates inheritance between classes by creating a class and extending its properties; logic; and behavior to other classes above it.
-
Working with JSON in
In Objective-C; you can use JASON to send and receive data over the Internet. In this video; Andy Alfred demonstrates how to encode and decode the JASON data by using Objective-C.
-
Using Transforms
While developing Windows Store apps using C#; you can transform the UI elements in your app. In this video; Andy Alfred demonstrates how to use transforms on UI elements.
