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
DotNET Frame work Notes For Professionals
فهرست مطالب کتاب DotNET Frame work Notes For Professionals:
Effective Modern C++ 42 Specific Ways to Improve Your Use of C++11 and C++14
فهرست مطالب کتاب Effective Modern C++:
- Deducing Types
- auto
- Moving to Modern C++
- Smart Pointers
- Rvalue References, Move Semantics, and Perfect Forwarding
- Lambda Expressions
- The Concurrency API
- Tweaks
Expert C Programming: Deep C Secrets
فهرست مطالب کتاب Expert C Programming:
ندارد
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