C Traps and Pitfalls

فهرست مطالب کتاب C Traps and Pitfalls:

Lexical pitfalls

Syntactic pitfalls

Semantic pitfalls

Linkage

Library functions

The preprocessor

Portability pitfalls

Advice and answers

C# Notes for Professionals

فهرست مطالب کتاب C# Notes for Professionals:

Getting started with C# Language

Literals

Operators

Conditional Statements

Equality Operator

Equals and GetHashCode

Null-Coalescing Operator

Null-conditional Operators

nameof Operator

Verbatim Strings

Common String Operations

Format

String Concatenate

String Manipulation

String Interpolation

String Escape Sequences

StringBuilder

Regex Parsing

DateTime Methods

Arrays

O(n) Algorithm for circular rotation of an array

Enum

Tuples

Guid

BigInteger

Collection Initializers

An overview of C# collections

Looping

Iterators

IEnumerable

Value type vs Reference type

Built-in Types

Aliases of built-in types

Anonymous types

Dynamic type

Type Conversion

Casting

Nullable types

Constructors and Finalizers

Access Modifiers

Interfaces

Static Classes

Singleton Implementation

Dependency Injection

Partial class and methods

Object initializers

Methods

Extension Methods

Named Arguments

Named and Optional Arguments

Data Annotation

Keywords

Object Oriented Programming In C#

Recursion

Naming Conventions

XML Documentation Comments

Comments and regions

Inheritance

Generics

Using Statement

Using Directive

IDisposable interface

Reflection

IQueryable interface

Linq to Objects

LINQ Queries

LINQ to XML

Parallel LINQ (PLINQ)

XmlDocument and the System.Xml namespace

XDocument and the System.Xml.Linq namespace

C# 7.0 Features

C# 6.0 Features

C# 5.0 Features

C# 4.0 Features

C# 3.0 Features

Exception Handling

NullReferenceException

Handling FormatException when converting string to other types

Read & Understand Stacktraces

Diagnostics

Overflow

Getting Started: Json with C#

Using json.net

Lambda expressions

Generic Lambda Query Builder

Properties

Initializing Properties

INotifyPropertyChanged interface

Events

Expression Trees

Overload Resolution

BindingList<T>

Preprocessor directives

Structs

Attributes

Delegates

File and Stream I/O

Networking

Performing HTTP requests

Reading and writing .zip files

FileSystemWatcher

Access network shared folder with username and password

Asynchronous Socket

Action Filters

Polymorphism

Immutability

Indexer

Checked and Unchecked

Stream

Timers

Stopwatches

Threading

Async/await, Backgroundworker, Task and Thread Examples

Async-Await

Synchronization Context in Async-Await

BackgroundWorker

Task Parallel Library

Making a variable thread safe

Lock Statement

Yield Keyword

Task Parallel Library (TPL) Dataflow Constructs

Functional Programming

Func delegates

Function with multiple return values

Binary Serialization

ICloneable

IComparable

Accessing Databases

Using SQLite in C#

Caching

Code Contracts

Code Contracts and Assertions

Structural Design Patterns

Creational Design Patterns

Implementing Decorator Design Pattern

Implementing Flyweight Design Pattern

Management.Automation

DirectoryServices.Protocols.LdapConnection

C# Authentication handler

Pointers

Pointers & Unsafe Code

How to use C# Structs to create a Union type (Similar to C Unions)

Reactive Extensions (Rx)

cs Examples

Creating a Console Application using a Plain-Text Editor and the C# Compiler (csc.exe)

CLSCompliantAttribute

ObservableCollection<T>

Hash Functions

Generating Random Numbers in C#

Cryptography (System.Security.Cryptography)

NET Identity

Unsafe Code in .NET

C# Script

Runtime Compile

Interoperability

.NET Compiler Platform (Roslyn)

ILGenerator

T4 Code Generation

Creating Own MessageBox in Windows Form Application

Including Font Resources

Import Google Contacts

Garbage Collector in .Net

Exchange.WebServices

Windows Communication Foundation

C++ Notes for Professionals

فهرست مطالب کتاب C++ Notes for Professionals:

Getting started with C++

Literals

operator precedence

Floating Point Arithmetic

Bit Operators

Bit Manipulation

Bit fields

Arrays

Iterators

Basic input/output in c++

Loops

File I/O

C++ Streams

Stream manipulators

Flow Control

Metaprogramming

const keyword

mutable keyword

Friend keyword

Type Keywords

Basic Type Keywords

Variable Declaration Keywords

Keywords

Returning several values from a function

Polymorphism

References

Value and Reference Semantics

C++ function “call by value” vs. “call by reference”

Copying vs Assignment

Pointers

Pointers to members

The This Pointer

Smart Pointers

Classes/Structures

Function Overloading

Operator Overloading

Function Template Overloading

Virtual Member Functions

Inline functions

Special Member Functions

Non-Static Member Functions

Constant class member functions

C++ Containers

Namespaces

Header Files

Using declaration

std::string

std::array

std::vector

std::map

std::optional

std::function: To wrap any element that is callable

std::forward_list

std::pair

std::atomics

std::variant

std::iomanip

std::any

std::set and std::multiset

std::integer_sequence

Using std::unordered_map

Standard Library Algorithms

The ISO C++ Standard

Inline variables

Random number generation

Date and time using <chrono> header

Sorting

Enumeration

Iteration

Regular expressions

Implementation-defined behavior

Exceptions

Lambdas

Value Categories

Preprocessor

Data Structures in C++

Templates

Expression templates

Curiously Recurring Template Pattern (CRTP)

Threading

Thread synchronization structures

The Rule of Three, Five, And Zero

RAII: Resource Acquisition Is Initialization

RTTI: Run-Time Type Information

Mutexes

Recursive Mutex

Semaphore

Futures and Promises

Atomic Types

Type Erasure

Explicit type conversions

Unnamed types

Type Traits

Return Type Covariance

Layout of object types

Type Inference

Typedef and type aliases

type deduction

Trailing return type

Alignment

Perfect Forwarding

decltype

SFINAE (Substitution Failure Is Not An Error)

Undefined Behavior

Overload resolution

Move Semantics

Pimpl Idiom

auto

Copy Elision

Fold Expressions

Unions

Design pattern implementation in C++

Singleton Design Pattern

User-Defined Literals

Memory management

C++11 Memory Model

Scopes

static_assert

constexpr

One Definition Rule (ODR)

Unspecified behavior

Argument Dependent Name Lookup

Attributes

Recursion in C++

Arithmitic Metaprogramming

Callable Objects

Client server examples

Const Correctness

Parameter packs

Build Systems

Concurrency With OpenMP

Resource Management

Storage class specifiers

Linkage specifications

Digit separators

C incompatibilities

Side by Side Comparisons of classic C++ examples solved via C++ vs C++11 vs C++14 vs C++17

Compiling and Building

Common compile/linker errors (GCC)

More undefined behaviors in C++

Unit Testing in C++

C++ Debugging and Debug-prevention Tools & Techniques

Optimization in C++

Optimization

Profiling

Refactoring Techniques

Clean Code : A Handbook of Agile Software Craftsmanship

فهرست مطالب کتاب Clean Code:

Chapter 1: Clean Code

Chapter 2: Meaningful Names

Chapter 3: Functions

Chapter 4: Comments

Chapter 5: Formatting

Chapter 6: Objects and Data Structures

Chapter 7: Error Handling

Chapter 8: Boundaries

Chapter 9: Unit Tests

Chapter 10: Classes

Chapter 11: Systems

Chapter 12: Emergence

Chapter 13: Concurrency

Chapter 14: Successive Refinement

Chapter 15: JUnit Internals

Chapter 16: Refactoring SerialDate

Chapter 17: Smells and Heuristics

Code Complete (Second Edition)

فهرست مطالب کتاب Code Complete:

Part I — Laying the Foundation

Welcome to Software Construction

Metaphors for a Richer Understanding of Software Development

Measure Twice, Cut Once: Upstream Prerequisites

Key Construction Decisions

Part II — Creating High-Quality Code

Design in Construction

Working Classes

High-Quality Routines

Defensive Programming

The Pseudocode Programming Process

Part III — Variables

General Issues in Using Variables

The Power of Variable Names

Fundamental Data Types

Unusual Data Types

Part IV — Statements

Organizing Straight-Line Code

Using Conditionals

Controlling Loops

Unusual Control Structures

Table-Driven Methods

General Control Issues

Part V — Code Improvements

The Software-Quality Landscape

Collaborative Construction

Developer Testing

Debugging

Refactoring

Code-Tuning Strategies

Code-Tuning Techniques

Part VI — System Considerations

How Program Size Affects Construction

Managing Construction

Integration

Programming Tools

Part VII — Software Craftsmanship

Layout and Style

Self-Documenting Code

Personal Character

Themes in Software Craftsmanship

Where to Find More Information

Continuous Delivery: Reliable Software Releases through Build

فهرست مطالب کتاب Continuous Delivery: Reliable Software Releases through Build:

Part I: Foundations

Chapter 1: The Problem of Delivering Software

Chapter 2: Configuration Management

Chapter 3: Continuous Integration

Chapter 4: Implementing a Testing Strategy

Part II: The Deployment Pipeline

Chapter 5: Anatomy of the Deployment Pipeline

Chapter 6: Build and Deployment Scripting

Chapter 7: The Commit Stage

Chapter 8: Automated Acceptance Testing

Chapter 9: Testing Nonfunctional Requirements

Chapter 10: Deploying and Releasing Applications

Part III: The Delivery Ecosystem

Chapter 11: Managing Infrastructure and Environments

Chapter 12: Managing Data

Chapter 13: Managing Components and Dependencies

Chapter 14: Advanced Version Control

Chapter 15: Managing Continuous Delivery

Data Structures and Algorithm Analysis in C

فهرست مطالب کتاب Data Structures and Algorithm Analysis in C:

PREFACE

CHAPTER 1: INTRODUCTION

CHAPTER 2: ALGORITHM ANALYSIS

CHAPTER 3: LISTS, STACKS, AND QUEUES

CHAPTER 4: TREES

CHAPTER 5: HASHING

CHAPTER 6: PRIORITY QUEUES (HEAPS)

CHAPTER 7: SORTING

CHAPTER 8: THE DISJOINT SET ADT

CHAPTER 9: GRAPH ALGORITHMS

CHAPTER 10: ALGORITHM DESIGN TECHNIQUES

CHAPTER 11: AMORTIZED ANALYSIS

Domain-Driven Design Distilled

فهرست مطالب کتاب Domain-Driven Design Distilled:

Chapter 1: DDD for Me

Chapter 2: Strategic Design with Bounded Contexts and the Ubiquitous Language

Chapter 3: Strategic Design with Subdomains

Chapter 4: Strategic Design with Context Mapping

Chapter 5: Tactical Design with Aggregates

Chapter 6: Tactical Design with Domain Events

Chapter 7: Acceleration and Management Tools

Effective Modern C++ 42 Specific Ways to Improve Your Use of C++11 and C++14

فهرست مطالب کتاب Effective Modern C++:

  1. Deducing Types
  2. auto
  3. Moving to Modern C++
  4. Smart Pointers
  5. Rvalue References, Move Semantics, and Perfect Forwarding
  6. Lambda Expressions
  7. The Concurrency API
  8. Tweaks

Git Notes For Professionals

فهرست مطالب Git Notes For Professionals:

Getting started with Git

Browsing the history

Working with Remotes

Staging

Ignoring Files and Folders

Git Diff

Undoing

Merging

Submodules

Committing

Aliases

Rebasing

Configuration

Branching

Rev-List

Squashing

Cherry Picking

Recovering

Git Clean

Using a .gitattributes file

.mailmap file: Associating contributor and email aliases

Analyzing types of workflows

Pulling

Hooks

Cloning Repositories

Stashing

Subtrees

Renaming

Pushing

Internals

git-tfs

Empty directories in Git

git-svn

Archive

Rewriting history with filter-branch

Migrating to Git

Show

Resolving merge conflicts

Bundles

Display commit history graphically with Gitk

Bisecting/Finding faulty commits

Blaming

Git revisions syntax

Worktrees

Git Remote

Git Large File Storage (LFS)

Git Patch

Git statistics

git send-email

Git GUI Clients

Reflog – Restoring commits not shown in git log

TortoiseGit

External merge and difftools

Update Object Name in Reference

Git Branch Name on Bash Ubuntu

Git Client-Side Hooks

Git rerere

Change git repository name

Git Tagging

Tidying up your local and remote repository

diff-tree