book

C# 6.0 in a Nutshell, 6th Edition

by Joseph Albahari, Ben Albahari

November 2015

Intermediate to advanced

1136 pages

28h 38m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Preface
Intended AudienceHow This Book Is OrganizedWhat You Need to Use This BookConventions Used in This BookUsing Code ExamplesO’Reilly SafariHow to Contact UsAcknowledgmentsJoseph AlbahariBen Albahari
1. Introducing C# and the .NET Framework
Object OrientationType SafetyMemory ManagementPlatform SupportC#’s Relationship with the CLRThe CLR and .NET FrameworkC# and Windows RuntimeWhat’s New in C# 6.0What Was New in C# 5.0What Was New in C# 4.0What Was New in C# 3.0
2. C# Language Basics
A First C# ProgramCompilationSyntaxIdentifiers and KeywordsLiterals, Punctuators, and OperatorsCommentsType BasicsPredefined Type ExamplesCustom Type ExamplesConversionsValue Types Versus Reference TypesPredefined Type TaxonomyNumeric TypesNumeric LiteralsNumeric ConversionsArithmetic OperatorsIncrement and Decrement OperatorsSpecialized Integral Operations8- and 16-Bit IntegralsSpecial Float and Double Valuesdouble Versus decimalReal-Number Rounding ErrorsBoolean Type and OperatorsBool ConversionsEquality and Comparison OperatorsConditional OperatorsStrings and CharactersChar ConversionsString TypeArraysDefault Element InitializationMultidimensional ArraysSimplified Array Initialization ExpressionsBounds CheckingVariables and ParametersThe Stack and the HeapDefinite AssignmentDefault ValuesParametersvar—Implicitly Typed Local VariablesExpressions and OperatorsPrimary ExpressionsVoid ExpressionsAssignment ExpressionsOperator Precedence and AssociativityOperator TableNull OperatorsNull-Coalescing OperatorNull-conditional operator (C# 6)StatementsDeclaration StatementsExpression StatementsSelection StatementsIteration StatementsJump StatementsMiscellaneous StatementsNamespacesThe using Directiveusing static (C# 6)Rules Within a NamespaceAliasing Types and NamespacesAdvanced Namespace Features
3. Creating Types in C#
ClassesFieldsMethodsInstance ConstructorsObject InitializersThe this ReferencePropertiesIndexersConstantsStatic ConstructorsStatic ClassesFinalizersPartial Types and MethodsThe nameof operator (C# 6)InheritancePolymorphismCasting and Reference ConversionsVirtual Function MembersAbstract Classes and Abstract MembersHiding Inherited MembersSealing Functions and ClassesThe base KeywordConstructors and InheritanceOverloading and ResolutionThe object TypeBoxing and UnboxingStatic and Runtime Type CheckingThe GetType Method and typeof OperatorThe ToString MethodObject Member ListingStructsStruct Construction SemanticsAccess ModifiersExamplesFriend AssembliesAccessibility CappingRestrictions on Access ModifiersInterfacesExtending an InterfaceExplicit Interface ImplementationImplementing Interface Members VirtuallyReimplementing an Interface in a SubclassInterfaces and BoxingEnumsEnum ConversionsFlags EnumsEnum OperatorsType-Safety IssuesNested TypesGenericsGeneric TypesWhy Generics ExistGeneric MethodsDeclaring Type Parameterstypeof and Unbound Generic TypesThe default Generic ValueGeneric ConstraintsSubclassing Generic TypesSelf-Referencing Generic DeclarationsStatic DataType Parameters and ConversionsCovarianceContravarianceC# Generics Versus C++ Templates
4. Advanced C#
DelegatesWriting Plug-in Methods with DelegatesMulticast DelegatesInstance Versus Static Method TargetsGeneric Delegate TypesThe Func and Action DelegatesDelegates Versus InterfacesDelegate CompatibilityEventsStandard Event PatternEvent AccessorsEvent ModifiersLambda ExpressionsExplicitly Specifying Lambda Parameter TypesCapturing Outer VariablesAnonymous Methodstry Statements and ExceptionsThe catch ClauseThe finally BlockThrowing ExceptionsKey Properties of System.ExceptionCommon Exception TypesThe TryXXX Method PatternAlternatives to ExceptionsEnumeration and IteratorsEnumerationCollection InitializersIteratorsIterator SemanticsComposing SequencesNullable TypesNullable<T> structImplicit and explicit nullable conversionsBoxing and unboxing nullable valuesOperator Liftingbool? with & and | OperatorsNullable Types & Null OperatorsScenarios for Nullable TypesAlternatives to Nullable TypesOperator OverloadingOperator FunctionsOverloading Equality and Comparison OperatorsCustom Implicit and Explicit ConversionsOverloading true and falseExtension MethodsExtension Method ChainingAmbiguity and ResolutionAnonymous TypesDynamic BindingStatic Binding Versus Dynamic BindingCustom BindingLanguage BindingRuntimeBinderExceptionRuntime Representation of DynamicDynamic Conversionsvar Versus dynamicDynamic ExpressionsDynamic Calls Without Dynamic ReceiversStatic Types in Dynamic ExpressionsUncallable FunctionsAttributesAttribute ClassesNamed and Positional Attribute ParametersAttribute TargetsSpecifying Multiple AttributesCaller Info Attributes (C# 5)Unsafe Code and PointersPointer BasicsUnsafe CodeThe fixed StatementThe Pointer-to-Member OperatorArraysvoid*Pointers to Unmanaged CodePreprocessor DirectivesConditional AttributesPragma WarningXML DocumentationStandard XML Documentation TagsUser-Defined TagsType or Member Cross-References
5. Framework Overview
The CLR and Core FrameworkSystem TypesText ProcessingCollectionsQueriesXMLDiagnostics and Code ContractsConcurrency and AsynchronyStreams and I/ONetworkingSerializationAssemblies, Reflection, and AttributesDynamic ProgrammingSecurityAdvanced ThreadingParallel ProgrammingApplication DomainsNative and COM InteroperabilityApplied TechnologiesUser Interface TechnologiesBackend TechnologiesDistributed System Technologies
6. Framework Fundamentals
String and Text HandlingCharStringComparing StringsStringBuilderText Encodings and UnicodeDates and TimesTimeSpanDateTime and DateTimeOffsetDates and Time ZonesDateTime and Time ZonesDateTimeOffset and Time ZonesTimeZone and TimeZoneInfoDaylight Saving Time and DateTimeFormatting and ParsingToString and ParseFormat ProvidersStandard Format Strings and Parsing FlagsNumeric Format StringsNumberStylesDate/Time Format StringsDateTimeStylesEnum Format StringsOther Conversion MechanismsConvertXmlConvertType ConvertersBitConverterGlobalizationGlobalization ChecklistTestingWorking with NumbersConversionsMathBigIntegerComplexRandomEnumsEnum ConversionsEnumerating Enum ValuesHow Enums WorkTuplesComparing TuplesThe Guid StructEquality ComparisonValue Versus Referential EqualityStandard Equality ProtocolsEquality and Custom TypesOrder ComparisonIComparable< and >Implementing the IComparable InterfacesUtility ClassesConsoleEnvironmentProcessAppContext
7. Collections
EnumerationIEnumerable and IEnumeratorIEnumerable<T> and IEnumerator<T>Implementing the Enumeration InterfacesThe ICollection and IList InterfacesICollection<T> and ICollectionIList<T> and IListIReadOnlyList<T>The Array ClassConstruction and IndexingEnumerationLength and RankSearchingSortingReversing ElementsCopyingConverting and ResizingLists, Queues, Stacks, and SetsList<T> and ArrayListLinkedList<T>Queue<T> and QueueStack<T> and StackBitArrayHashSet<T> and SortedSet<T>DictionariesIDictionary<TKey,TValue>IDictionaryDictionary<TKey,TValue> and HashtableOrderedDictionaryListDictionary and HybridDictionarySorted DictionariesCustomizable Collections and ProxiesCollection<T> and CollectionBaseKeyedCollection<TKey,TItem> and DictionaryBaseReadOnlyCollection<T>Plugging in Equality and OrderIEqualityComparer and EqualityComparerIComparer and ComparerStringComparerIStructuralEquatable and IStructuralComparable
8. LINQ Queries
Getting StartedFluent SyntaxChaining Query OperatorsComposing Lambda ExpressionsNatural OrderingOther OperatorsQuery ExpressionsRange VariablesQuery Syntax Versus SQL SyntaxQuery Syntax Versus Fluent SyntaxMixed-Syntax QueriesDeferred ExecutionReevaluationCaptured VariablesHow Deferred Execution WorksChaining DecoratorsHow Queries Are ExecutedSubqueriesSubqueries and Deferred ExecutionComposition StrategiesProgressive Query BuildingThe into KeywordWrapping QueriesProjection StrategiesObject InitializersAnonymous TypesThe let KeywordInterpreted QueriesHow Interpreted Queries WorkCombining Interpreted and Local QueriesAsEnumerableLINQ to SQL and Entity FrameworkLINQ to SQL Entity ClassesEntity Framework Entity ClassesDataContext and ObjectContextAssociationsDeferred Execution with L2S and EFDataLoadOptionsEager Loading in Entity FrameworkUpdatesAPI Differences Between L2S and EFBuilding Query ExpressionsDelegates Versus Expression TreesExpression Trees
9. LINQ Operators
OverviewSequence→SequenceSequence→Element or ValueVoid→SequenceFilteringWhereTake and SkipTakeWhile and SkipWhileDistinctProjectingSelectSelectManyJoiningJoin and GroupJoinThe Zip OperatorOrderingOrderBy, OrderByDescending, ThenBy, and ThenByDescendingGroupingGroupBySet OperatorsConcat and UnionIntersect and ExceptConversion MethodsOfType and CastToArray, ToList, ToDictionary, and ToLookupAsEnumerable and AsQueryableElement OperatorsFirst, Last, and SingleElementAtDefaultIfEmptyAggregation MethodsCount and LongCountMin and MaxSum and AverageAggregateQuantifiersContains and AnyAll and SequenceEqualGeneration MethodsEmptyRange and Repeat

10. LINQ to XML
Architectural OverviewWhat Is a DOM?The LINQ to XML DOMX-DOM OverviewLoading and ParsingSaving and SerializingInstantiating an X-DOMFunctional ConstructionSpecifying ContentAutomatic Deep CloningNavigating and QueryingChild Node NavigationParent NavigationPeer Node NavigationAttribute NavigationUpdating an X-DOMSimple Value UpdatesUpdating Child Nodes and AttributesUpdating Through the ParentWorking with ValuesSetting ValuesGetting ValuesValues and Mixed Content NodesAutomatic XText ConcatenationDocuments and DeclarationsXDocumentXML DeclarationsNames and NamespacesNamespaces in XMLSpecifying Namespaces in the X-DOMThe X-DOM and Default NamespacesPrefixesAnnotationsProjecting into an X-DOMEliminating Empty ElementsStreaming a ProjectionTransforming an X-DOM
11. Other XML Technologies
XmlReaderReading NodesReading ElementsReading AttributesNamespaces and PrefixesXmlWriterWriting AttributesWriting Other Node TypesNamespaces and PrefixesPatterns for Using XmlReader/XmlWriterWorking with Hierarchical DataMixing XmlReader/XmlWriter with an X-DOMXSD and Schema ValidationPerforming Schema ValidationXSLT
12. Disposal and Garbage Collection
IDisposable, Dispose, and CloseStandard Disposal SemanticsWhen to DisposeOpt-in DisposalClearing Fields in DisposalAutomatic Garbage CollectionRootsGarbage Collection and WinRTFinalizersCalling Dispose from a FinalizerResurrectionHow the Garbage Collector WorksOptimization TechniquesForcing Garbage CollectionTuning Garbage CollectionMemory PressureManaged Memory LeaksTimersDiagnosing Memory LeaksWeak ReferencesWeak References and CachingWeak References and Events
13. Diagnostics and Code Contracts
Conditional CompilationConditional Compilation Versus Static Variable FlagsThe Conditional AttributeDebug and Trace ClassesFail and AssertTraceListenerFlushing and Closing ListenersCode Contracts OverviewWhy Use Code Contracts?Contract PrinciplesPreconditionsContract.RequiresContract.Requires<TException>Contract.EndContractBlockPreconditions and Overridden MethodsPostconditionsContract.EnsuresContract.EnsuresOnThrow<TException>Contract.Result<T> and Contract.ValueAtReturn<T>Contract.OldValue<T>Postconditions and Overridden MethodsAssertions and Object InvariantsAssertionsObject InvariantsContracts on Interfaces and Abstract MethodsDealing with Contract FailureThe ContractFailed EventExceptions Within Contract ConditionsSelectively Enforcing ContractsContracts in Release BuildsCall-Site CheckingStatic Contract CheckingThe ContractVerification AttributeBaselinesThe SuppressMessage AttributeDebugger IntegrationAttaching and BreakingDebugger AttributesProcesses and Process ThreadsExamining Running ProcessesExamining Threads in a ProcessStackTrace and StackFrameWindows Event LogsWriting to the Event LogReading the Event LogMonitoring the Event LogPerformance CountersEnumerating the Available CountersReading Performance Counter DataCreating Counters and Writing Performance DataThe Stopwatch Class
14. Concurrency and Asynchrony
IntroductionThreadingCreating a ThreadJoin and SleepBlockingLocal Versus Shared StateLocking and Thread SafetyPassing Data to a ThreadException HandlingForeground Versus Background ThreadsThread PrioritySignalingThreading in Rich-Client ApplicationsSynchronization ContextsThe Thread PoolTasksStarting a TaskReturning valuesExceptionsContinuationsTaskCompletionSourceTask.DelayPrinciples of AsynchronySynchronous Versus Asynchronous OperationsWhat is Asynchronous Programming?Asynchronous Programming and ContinuationsWhy Language Support Is ImportantAsynchronous Functions in C# AwaitingWriting Asynchronous FunctionsAsynchronous Lambda ExpressionsAsynchronous Methods in WinRTAsynchrony and Synchronization ContextsOptimizationsAsynchronous PatternsCancellationProgress ReportingThe Task-based Asynchronous Pattern (TAP)Task CombinatorsObsolete PatternsAsynchronous Programming Model (APM)Event-Based Asynchronous Pattern (EAP)BackgroundWorker
15. Streams and I/O
Stream ArchitectureUsing StreamsReading and WritingSeekingClosing and FlushingTimeoutsThread SafetyBacking Store StreamsFileStreamMemoryStreamPipeStreamBufferedStreamStream AdaptersText AdaptersBinary AdaptersClosing and Disposing Stream AdaptersCompression StreamsCompressing in MemoryWorking with ZIP FilesFile and Directory OperationsThe File ClassThe Directory ClassFileInfo and DirectoryInfoPathSpecial FoldersQuerying Volume InformationCatching Filesystem EventsFile I/O in Windows RuntimeWorking with DirectoriesWorking with FilesIsolated Storage in Windows Store AppsMemory-Mapped FilesMemory-Mapped Files and Random File I/OMemory-Mapped Files and Shared MemoryWorking with View AccessorsIsolated StorageIsolation TypesReading and Writing Isolated StorageStore LocationEnumerating Isolated Storage
16. Networking
Network ArchitectureAddresses and PortsURIsClient-Side ClassesWebClientWebRequest and WebResponseHttpClientProxiesAuthenticationException HandlingWorking with HTTPHeadersQuery StringsUploading Form DataCookiesForms AuthenticationSSLWriting an HTTP ServerUsing FTPUsing DNSSending Mail with SmtpClientUsing TCPConcurrency with TCPReceiving POP3 Mail with TCPTCP in Windows Runtime
17. Serialization
Serialization ConceptsSerialization EnginesFormattersExplicit Versus Implicit SerializationThe Data Contract SerializerDataContractSerializer Versus NetDataContractSerializerUsing the SerializersSerializing SubclassesObject ReferencesVersion ToleranceMember OrderingNull and Empty ValuesData Contracts and CollectionsSubclassed Collection ElementsCustomizing Collection and Element NamesExtending Data ContractsSerialization and Deserialization HooksInteroperating with [Serializable]Interoperating with IXmlSerializableThe Binary SerializerGetting StartedBinary Serialization Attributes[NonSerialized][OnDeserializing] and [OnDeserialized][OnSerializing] and [OnSerialized][OptionalField] and VersioningBinary Serialization with ISerializableSubclassing Serializable ClassesXML SerializationGetting Started with Attribute-Based SerializationSubclasses and Child ObjectsSerializing CollectionsIXmlSerializable
18. Assemblies
What’s in an AssemblyThe Assembly ManifestThe Application ManifestModulesThe Assembly ClassStrong Names and Assembly SigningHow to Strongly Name an AssemblyDelay SigningAssembly NamesFully Qualified NamesThe AssemblyName ClassAssembly Informational and File VersionsAuthenticode SigningHow to Sign with AuthenticodeAuthenticode ValidationThe Global Assembly CacheHow to Install Assemblies to the GACGAC and VersioningResources and Satellite AssembliesDirectly Embedding Resources.resources Files.resx FilesSatellite AssembliesCultures and SubculturesResolving and Loading AssembliesAssembly and Type Resolution RulesAssemblyResolveLoading AssembliesDeploying Assemblies Outside the Base FolderPacking a Single-File ExecutableSelective PatchingWorking with Unreferenced Assemblies
19. Reflection and Metadata
Reflecting and Activating TypesObtaining a TypeType NamesBase Types and InterfacesInstantiating TypesGeneric TypesReflecting and Invoking MembersMember TypesC# Members Versus CLR MembersGeneric Type MembersDynamically Invoking a MemberMethod ParametersUsing Delegates for PerformanceAccessing Nonpublic MembersGeneric MethodsAnonymously Calling Members of a Generic InterfaceReflecting AssembliesLoading an Assembly into a Reflection-Only ContextModulesWorking with AttributesAttribute BasicsThe AttributeUsage AttributeDefining Your Own AttributeRetrieving Attributes at RuntimeRetrieving Attributes in the Reflection-Only ContextDynamic Code GenerationGenerating IL with DynamicMethodThe Evaluation StackPassing Arguments to a Dynamic MethodGenerating Local VariablesBranchingInstantiating Objects and Calling Instance MethodsException HandlingEmitting Assemblies and TypesSaving Emitted AssembliesThe Reflection.Emit Object ModelEmitting Type MembersEmitting MethodsEmitting Fields and PropertiesEmitting ConstructorsAttaching AttributesEmitting Generic Methods and TypesDefining Generic MethodsDefining Generic TypesAwkward Emission TargetsUncreated Closed GenericsCircular DependenciesParsing ILWriting a Disassembler
20. Dynamic Programming
The Dynamic Language RuntimeNumeric Type UnificationDynamic Member Overload ResolutionSimplifying the Visitor PatternAnonymously Calling Members of a Generic TypeImplementing Dynamic ObjectsDynamicObjectExpandoObjectInteroperating with Dynamic LanguagesPassing State Between C# and a Script
21. Security
PermissionsCodeAccessPermission and PrincipalPermissionPermissionSetDeclarative Versus Imperative SecurityCode Access Security (CAS)How Code Access Security Is AppliedTesting for Full TrustAllowing Partially Trusted CallersElevation of PrivilegeAPTCA and [SecurityTransparent]The Transparency ModelHow the Transparency Model WorksHow to Write APTCA Libraries with TransparencyTransparency in Full-Trust ScenariosSandboxing Another AssemblyAsserting PermissionsOperating System SecurityRunning in a Standard User AccountAdministrative Elevation and VirtualizationIdentity and Role SecurityAssigning Users and RolesCryptography OverviewWindows Data ProtectionHashingSymmetric EncryptionEncrypting in MemoryChaining Encryption StreamsDisposing Encryption ObjectsKey ManagementPublic Key Encryption and SigningThe RSA ClassDigital Signing
22. Advanced Threading
Synchronization OverviewExclusive LockingThe lock StatementMonitor.Enter and Monitor.ExitChoosing the Synchronization ObjectWhen to LockLocking and AtomicityNested LockingDeadlocksPerformanceMutexLocking and Thread SafetyThread Safety and .NET Framework TypesThread Safety in Application ServersImmutable ObjectsNonexclusive LockingSemaphoreReader/Writer LocksSignaling with Event Wait HandlesAutoResetEventManualResetEventCountdownEventCreating a Cross-Process EventWaitHandleWait Handles and ContinuationsConverting Wait Handles to TasksWaitAny, WaitAll, and SignalAndWaitThe Barrier ClassLazy InitializationLazy<T>LazyInitializerThread-Local Storage[ThreadStatic]ThreadLocal<T>GetData and SetDataInterrupt and AbortSuspend and ResumeTimersMultithreaded TimersSingle-Threaded Timers
23. Parallel Programming
Why PFX?PFX ConceptsPFX ComponentsWhen to Use PFXPLINQParallel Execution BallisticsPLINQ and OrderingPLINQ LimitationsExample: Parallel SpellcheckerFunctional PuritySetting the Degree of ParallelismCancellationOptimizing PLINQThe Parallel ClassParallel.InvokeParallel.For and Parallel.ForEachTask ParallelismCreating and Starting TasksWaiting on Multiple TasksCanceling TasksContinuationsTask SchedulersTaskFactoryWorking with AggregateExceptionFlatten and HandleConcurrent CollectionsIProducerConsumerCollection<T>ConcurrentBag<T>BlockingCollection<T>Writing a Producer/Consumer Queue
24. Application Domains
Application Domain ArchitectureCreating and Destroying Application DomainsUsing Multiple Application DomainsUsing DoCallBackMonitoring Application DomainsDomains and ThreadsSharing Data Between DomainsSharing Data via SlotsIntra-Process RemotingIsolating Types and Assemblies
25. Interoperability
Calling into Native DLLsType MarshalingMarshaling Common TypesMarshaling Classes and StructsIn and Out MarshalingCallbacks from Unmanaged CodeSimulating a C UnionShared MemoryMapping a Struct to Unmanaged Memoryfixed and fixed {...}COM InteroperabilityThe Purpose of COMThe Basics of the COM Type SystemCalling a COM Component from C# Optional Parameters and Named ArgumentsImplicit ref ParametersIndexersDynamic BindingEmbedding Interop TypesType EquivalencePrimary Interop AssembliesExposing C# Objects to COM
26. Regular Expressions
Regular Expression BasicsCompiled Regular ExpressionsRegexOptionsCharacter EscapesCharacter SetsQuantifiersGreedy Versus Lazy QuantifiersZero-Width AssertionsLookahead and LookbehindAnchorsWord BoundariesGroupsNamed GroupsReplacing and Splitting TextMatchEvaluator DelegateSplitting TextCookbook Regular ExpressionsRecipesRegular Expressions Language Reference
27. The Roslyn Compiler
Roslyn ArchitectureWorkspacesSyntax TreesSyntaxTree StructureObtaining a Syntax TreeTraversing and Searching a TreeTriviaTransforming a Syntax TreeCompilations and Semantic ModelsCreating a CompilationEmitting an AssemblyQuerying the Semantic ModelExample: Renaming a Symbol
Index

Overview

When you have questions about C# 6.0 or the .NET CLR and its core Framework assemblies, this bestselling guide has the answers you need. C# has become a language of unusual flexibility and breadth since its premiere in 2000, but this continual growth means there’s still much more to learn.

Organized around concepts and use cases, this thoroughly updated sixth edition provides intermediate and advanced programmers with a concise map of C# and .NET knowledge. Dive in and discover why this Nutshell guide is considered the definitive reference on C#.

Get up to speed with all aspects of the C# language, from the basics of syntax and variables, to advanced topics such as pointers and operator overloading
Dig deep into LINQ via three chapters dedicated to the topic
Learn about dynamic, asynchronous, and parallel programming
Work with .NET features, including XML, networking, serialization, reflection, security, application domains, and code contracts
Explore the new C# 6.0 compiler-as-a-service, Roslyn

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781491927090Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills