11 September 2021
Version 4.0.6 is going out today. This is another digital-only update, fixing a typo and a minor improvement to the sample code:
- Fixed a mis-numbering of the “Methods” knowledge check answers on page 269.
- Added in a
readonlymodifier to the
_numberLockfield in the sample on page 339, since it doesn’t need to change after creation.
Earlier, I had committed to monthly digital updates through the third quarter (July, August, September). 4.0.6 represents that last of that original commitment.
I have not yet made plans for the fourth quarter of the year, but at this point, I think it is a safe assumption to expect at least an update the first weekends of October and November.
The caveat to that plan would be that if there are no reported issues, then there won’t be an update. (Though I think I’d likely still post an update here, saying so.)
8 August 2021
Version 4.0.5 is going out today. This is another digital-only update, fixing minor typos and a few other tweaks. This is also the smallest update, in terms of total changes, so far, which is a trend I generally expect to continue going forward.
The changes include:
- Fixing the title in the headers of Level 53 (said Bonus Level A instead of Into Lands Uncharted as they were supposed to say). Thanks @odigity!
- A couple of corrections to the code sample on page 339 about using locks to enforce thread safety. Thanks @Powder!
- Added a missing
$to a string interpolation for the code at the very bottom of page 266. Thanks @Powder!
- A slight tweak to the Safer Number Crunching challenge on page 267 to indicate using the
int.TryParse(string s, out int result)method (as shown earlier in that section) instead of the non-existent
int.TryParse(out int value)method (missing the first string parameter). Thanks @Powder and @Kranberry!
- An updated version of the XP Tracker on the website to fix some outdated challenge entries. Thanks @AddAmazeing!
I also added two new articles on the website as a part of this update:
- Locks and Reading Data: Discusses locks in a bit more depth to cover some ground that the book doesn’t quite capture. Worth a read if you’re doing much with multi-threading and concurrency in C#. This is in response to the deeper analysis I did while fixing #2 above, so thanks again, @Powder!
- Lists and
InvalidOperationExceptions. The book mentions that you can use
foreachon a list, but that if you add, remove, or swap out items in a list while in the middle of a
foreach, you’ll get an exception. It then mentions that there are two ways to get around the problem, and describes how you can just use a
forloop. But it does not cover the second option. This article covers it. Thanks for asking about it, @JustPlay!
6 July 2021
Version 4.0.4 is going out today. This is another digital-only update, fixing minor typos and a few small other tweaks.
- On pages 199 and 200, The
IsOnBoardmethod was incorrectly using
row, using the property instead of the parameter. This has now been fixed.
- On page 243 and 244, there were a couple of sentences that called out arrays, when the topic was actually lists.
- On page 372, the second bitshift example was wrong. It said “00010001 becomes 00000100,” but should have said “00010001 becomes 00000010.”
- On page 379, I reordered the
Console.WriteLine(number);lines in the example so the
forversions worked in the same way.
- On page 380, the sample said
Add(newShip()), but that should have read
Add(new Ship())(which changes it to correctly calling the
Shipconstructor instead of a mysterious
- A couple of other minor typos.
On the website, I have also made a couple of minor tweaks as well:
- Some tweaks to the CRC cards for Hangman on the website.
- The solution for the challenge called The Color now uses static properties instead of static fields, as required by the challenge description.
This is the smallest update we’ve had, though it still contains about 12 typo corrections and minor improvements.
Back when the book was first released, I mentioned that for April, May, and June, you should expect an update the first weekend of the month. That has carried over into July now, and I think it is reasonable to expect that to continue for August and September as well.
I also want to say that I’ve been spending some time trying to get an epub and/or mobi version of the book available, since I know that format works better on smaller screens and ebook readers are optimized for flexible-layout formats. The tough part is not the epub or mobi side, it is ensuring the workflow still allows me to make both EPUB and PDF versions, while still retaining all of the features I’ve got in the PDF. I had hoped to start putting out some work-in-progress versions before the end of June, but that hasn’t happened yet, and still looks to be a ways out still. I currently expect that 5th Edition (whenever that is, but it doesn’t feel like C# 10 is immiment) will have EPUB or MOBI (or both) available.
6 June 2021
Version 4.0.3 is going out today. This is a digital-only update, fixing minor typos and adding clarity in a few small corner cases.
This was supposed to be the May 2021 update, but it kept getting pushed back until now, and so the May and June updates are combined in this update.
There are a handful of minor issues that have been reported to me in the last couple of days that didn’t make it into this update. They’ll make it into the next one, which I’m planning for the first weekend in July. (That’s a long weekend for me. I won’t consider the update late until the 6th of July.)
The errata page has gotten pretty crowded now, though you may notice that (a) the vast majority are minor typos and (b) most are late in the book. I don’t think the later part of the book had any less attention than earlier parts of the book, but I have a couple of readers with sharp eyes that happen to have been through most of the book already (in Early Access) before it was published.
4 April 2021
Version 4.0.2 is going out today. The first digital edition release was 4.0.0, and the first print edition was 4.0.1.
This will be a digital-only update, fixing some minor typos and adding a bit of clarity in a few small corner cases.
This isn’t a commitment, but I am tentatively planning on doing updates of this nature once a month, usually on the first weekend of the month, so the next one might be early May.
23 March 2021
The physical 4th Edition of The C# Player’s Guide is now available on Amazon! Here’s the link: https://amzn.to/2PlxQCW
It’s been a long journey, but I’m over-the-moon excited about this edition finally becoming available! The “Look Inside” feature doesn’t work yet (I’ll ask, but I think it usually takes a few days) but if you want a preview before buying, you can always look at the sample that is available from the home page.
21 March 2021
The ISBN-related issues have been resolved, and it is now just pending a review by Amazon before it will appear there! They’ve said to allow up to three days, though I think there are reasons to believe it may be somewhat less than that.
20 March 2021
The latest on the physical edition is that at this point, I’m waiting on processes outside of my control to happen. It will take up to five more days for the ISBN information to propagate through the system, and then up to another three days for the book to become available. My best guess is neither will take as long as the worst-case scenarios they state, but there’s no way to be sure right now. (And there’s always the possibility of some other unforeseen circumstance.)
I’ll try to keep this page updated as I learn more information.
14 March 2021
The 4th Edition has arrived in digital form!
This week’s changes involve small fixes for a high quantity of typo reports and suggestions scattered throughout the book.
Given that this is the first official release of the 4th Edition, you might also find this article useful to you, which describes all of the changes made for 4th Edition vs. 3rd Edition at a high level: https://csharpplayersguide.com/articles/whats-new-4th-edition.html.
This ends the Early Access program that has been running since late October. Going forward, the digital edition on Gumroad will continue to get periodic updates, though not at the same weekly cadence as before. My best guess is that this will be more like monthly, and only if there are things worth doing an update for.
The physical edition will be available soon, likely by the end of this week. It’s a longer process to get that approved, but now pushing it through that process is the only thing left.
It is a slow process with some consequences (usually some downtime in availability) but typo corrections can be done even in print. (Obviously, anybody whose book was already printed won’t get the corrections. Alas, we’ll have to just live with that.) So while it will be at a lower rate, there is still the possibility of limited corrections, even in print form.
Despite the slower update rate, please don’t hesitate to report any issues you find in the book, big or small.
The errata page on the website can be updated almost instantly, and any necessary change will find their way to the digital and print versions before too long.
While this isn’t a commitment, I fully expect that there will be a 5th Edition in due time. There will be new versions of C#, and I intend on keeping the book up-to-date with that. So even broad, sweeping suggestions can be addressed before too much time passes. (I currently have no clear insight into when this might be. We’ll probably know more at Microsoft’s Build conference in May.)
As Early Access winds down, I want to say again how nice it has been to have so many of you along on the journey with me. Thanks to your efforts, the book is far better than it ever would have been otherwise. (Again, no promises on exactly how things will unfold, but I hope to see many of you again for the next Early Access!)
13 March 2021
This week’s update is delayed by a day. I usually get the update out Friday or Saturday, but I’ve got a few final things to take care of before pushing this one out. Normally, I’d just let loose ends go until the next release, but this will be the first official release, and it may be a bit longer until the next update.
6 March 2021
Release Candidate #4 is now available!
This may be the final release candidate, as Visual Studio 16.9–the sole impediment to the release–is now out!
A few minor fixes readers reported have been fixed, and I also made a couple of small tweaks to the section on making new projects with the templates.
I’m waiting on one final print copy to review this week, but unless there is some big problem that comes out of that, the final release may be available in one week. (Treat that as a guess, not a promise.)
27 February 2021
Release Candidate #3 is now available!
The final revision pass is complete, as are all loose ends that I wanted to finish. At this point, there is nothing specific I want to accomplish with the book that isn’t already done.
It now becomes a waiting game. The book assumes that you are using the new (upcoming) template system instead of the old (current) template system. This is supposed to be the default in Visual Studio 16.9, though you can turn it on in 16.8 (the current release). The book has a page (now says STOP in big obvious letters so you don’t miss it) that describes how to switch over to this new system. But my intent was to wait for Visual Studio 16.9 to be released before publishing the final edition of the book. So that’s what we’re waiting on.
I may yet decide it isn’t worth waiting, rework the book to account for both template systems, and just go ahead with the release before 16.9 comes out.
In the meantime, any issues readers find will still be fixed; expect the weekly releases to continue for now.
20 February 2021
Release Candidate #2 is now available!
The primary accomplishment is working through the final revision pass. This is now 90% complete.
I spent some time working on video walkthroughs before deciding that it was a lot of work and not a lot of value, so I decided not to do it. If it’s something people would find valuable, we can still do it as a live stream through Discord and make the recordings available on the website.
All that’s left is this:
- Finish the revision pass.
- A few tiny loose ends.
- Fix problems submitted by readers.
If you haven’t joined the discord server, I’d love to see you over there! https://discord.gg/Wx8VMUbk68
12 February 2021
We’ve made it to our first Release Candidate, with Release Candidate #1 coming out today!
The big accomplishments of the past week are:
- Made a new Discord server specifically for this book. Come join the fun!
- Updated the XP Tracker at the beginning of the book.
- Updated the Map at the beginning of the book.
- Updated the title page at the beginning of the book.
- Added an illustration to the Final Battle challenge in Level 52.
- Turned four challenges into Boss Battles (the big ones, though several are multi-part).
- Hunting the Manticore
- Catacombs of the Class
- Fountain of Objects
- The Final Battle
- Changed the visual appearance of the CRC cards.
The plans for the coming week are:
- Yet another revision pass. (This should be much faster than the last. I spent a few hours and got through four chapters, so I don’t expect this one to drag on for weeks like the last round.)
- I am planning on (but not committing to) making some video walkthroughs of the Boss Battles to put online. I think these videos will show more nuance to the development process than a simple snapshot of the final result.
And of course, fix the things you guys report.
5 February 2021
Early Access #17 is out today.
The big updates are:
- The cover is now finished.
- The website is now finished.
- The back of the book is now basically finished, notably: a. The Operators table was moved to the website: /articles/operators-table. b. The Keywords table was eliminated. Nobody was using it, and it didn’t really seem to be providing much value. c. The Built-In Types diagram and table were totally redone and moved to the end of Level 6. (You should check it out!)
The final few items are these:
- Finish the front part of the book. In particular, the XP Tracker and map need some updates and tweaks.
- A few other items that have bene kicking around on the GitHub issue tracker, though some of those will also need to wait for 5th Edition, unfortunately. (Don’t hesitate to go there and get involved in the discussions there.)
- Additional changes as feedback continues coming in.
I think there’s an 80% chance all of that will get finished this week, so whether the book is done in one week or not is largely dependent on what else pops up that I decide to do.
Also keep in mind that I’m currently somewhat on the hook to wait for Visual Studio 16.9, which isn’t out yet, and still feels like it is at least two weeks out, if not more. If that truly becomes the only thing I’m waiting on, I might change course on it.
29 January 2021
Early Access #16 is out today.
The bulk of my time this last week was on getting the website up and running. There are three key elements that you should be aware of:
- There is a new home: csharpplayersguide.com
- The website takes much better advantage of reactive web design, so you should have a better experience on phones and tablets.
- The solutions are now available there (csharpplayersguide.com/solutions), and will therefore no longer be included as a download here, as there is no longer a need for it.
I also spent some time working with a graphic designer on the cover, and am planning on going with the blue sword+circle design, with a handful of tweaks and refinements.
I will be continuing to work on the website and the cover this coming week, and also finishing up the final revision pass on the Tables and Charts at the back of the book, as well as the map and XP tracker at the start. To that end, I’d love to get a better feel for if and how you use the Tables and Charts at the back of the book. If you could take just a minute or two and fill out this survey, it would give me a great deal of insight into where I should go with it: https://www.surveymonkey.com/r/XSPCSFC
In short, the coming week is:
- Finish the cover.
- Finish the website.
- Finish the front and back parts of the book.
- Fix issues you report.
There is a teeny tiny chance I’ll be finished with all of those for Early Access #17. (Probably less than 5%, but this is the first time there has been a chance.)
22 January 2021
Early Access #15 just went out today.
The final revision pass is now complete, and there are only two major efforts left:
- Update the cover.
- Update the website.
There are some other more minor things, and I’m expecting to still get more issues submitted from readers, but those are the big ones.
For me, this feels like the beginning of the end. There’s still plenty more to do (and I’m not expecting a release in January) but we’re getting to the end.
15 January 2021
This week, nearly all of the effort went into the final revision pass and made pretty good progress. I am about 58% of the way through the book, up through the level on Files, though the Introduction and Part 2 and Part 3 intro pages have also not been covered yet.
There were several other typos that people found, including a couple that my final revision pass missed. (Things that were not strictly wrong, but that were still awkward and deserved improvement.) So even though I’m going through this final revision pass, don’t hesitate to send me anything you notice so that we can make sure we get them all.
This revision pass is the main focus for the coming week.
I’m currently estimating about 50 hours to go on this final revision pass, which has a chance of being finished up for this next release. I might put off the release until Saturday evening if I think I can get it all finalized. So next week’s update might be on the late side.
8 January 2021
The 13th early access release of the C# Player’s Guide, 4th Edition is now available.
The bulk of the effort has gone in to making the final revision pass through the book. I completed Level 18 in that process, which puts me at about 25% of the way done, and an estimated 108 hours to go, which is probably three full weeks.
I also fixed a ton of small typos and grammar fixes that people reported–probably more than any other single week. Keep them coming!
I got some feedback from a couple of people on the potential cover designs over the week, and am still interested in hearing more. I haven’t done anything with them due to focusing on the final revision pass, but I appreciate the comments I have received so far.
1 January 2021
The 12th Early Access for The C# Player’s Guide, 4th Edition is now available.
The biggest accomplishment was finishing the challenges. The biggest change came with The Final Battle challenges, which was a complete do-over.
Aside from that, I got the process of designing a new cover underway. I have a couple of options:
Option #1: Just keep the current cover, more or less intact as it is now. Probably a tweak to the edition number color. That cyan that is currently in there was quick and dirty. Option #2: A second design I got with some color variations. These are in the downloads on Gumroad. There are four variations, different only by color (I believe). Option #3: Pay another graphic designer to come up with a completely different choice. (I work with several that do pretty good work.)
I know you’re not buying the book because of the cover, but I’m definitely interested in getting a broad set of opinions on it. If you prefer the cover as it currently stands to this new Option 2 that is in the downloads, I want to hear that. If you like this alternative, I want to know that too. If one of the four color variations stands out as a favorite (or one you especially dislike), I want to hear that.
I did get the final revision pass started, though it is really only just beginning, and I can already tell it is going to take more time than I had initially anticipated. That puts the release date in more like early to mid February, but the to-do list is starting to get pretty short, and I don’t expect huge delays beyond that, now that I’ve got my teeth in the last major effort.
There was also the usual assortment of small tweaks and typos that were fixed.
27 December 2020
Early Access #11 is now available. Here are the release notes:
The primary focus was on creating answers to the challenges. To that end, all of Part 3 now has solutions (they all got tweaked a little in the process to add more consistency). Part 5 also has answers to the challenges. Other than a few stragglers from earlier in the book, everything is done except the Final Battle–a whole set of challenges right at the end of the book.
The big problem I had this week is that I decided that Final Battle challenge was too hard. I stripped out some of the primary elements and made another challenge, but I decided yesterday that it, too, was too hard. At least this time, I felt it could be tweaked into something that works, rather than having to retool it from scratch. That is still a work in progress, but included in the challenge solution code, I have both the more complex version of the program up and running (‘Level 52 - The Final Battle/ TheFinalBattle’) as well as my beginning attempts to simplify it (‘Level 52 - The Final Battle/TheFinalBattleSimplified’). I’m not done simplifying yet, but you can see it where things stand. Also ‘Level 52 - The Final Battle/Description.txt’ contains an extremely rough description of the challenges–as I thought they might be before simplifying. I’ve included all of that in this update, though I expect it will be cleaned up by next week.
I also fixed a number of small issues that readers found. The typos and grammar fixes
have all been addressed, though there are a few suggestions still hanging out that need
attention in future releases. (A suggestion to include the Parts as bookmarks, a
suggestion to include an EPUB format, and a suggestion to include something about
StringBuilder, among other things.)
Overall, I made less progress on these challenge solutions than I had hoped. That delays the final release by a bit. I’m now confident it will not be December, so I am now targeting late January. I think there’s at least of month of work left. I do have all of this coming week off. If things go well, that might change for the better, but based on this past week, I can’t make promises.
18 December 2020
Early Access #10 is now available. Here are the release notes:
The primary focus this time has been on providing solutions to all of the challenges in the book. To that end, there are now solutions for nearly all challenges in Part 1 and Part 2. There were a few where the challenge itself needed some substantial changes, and those have not been included yet. The missing ones are “Casting and Order of Operations” and “Positive or Negative” from Part 1 and “Containers,” “Generic Containers,” and “Lists of Inventory” from Part 2.
Several challenges–especially the “Hunting the Manticore” and “Fountain of Objects” challenges–were changed rather significantly to make them easier. If you gave either of those an attempt and struggled before, try the updated version again. Those are meant to be tough challenges, but the bar was probably set just a little too high.
There were a small number of other small typos and similar fixes, though far fewer than in the past. But I was able to fix all reported issues of that nature.
I expect that creating solutions will be finished by the next update.
I am still interested in feedback about the fonts and visual style. I recieved just a couple of comments on that, and want to make sure I get it right.
And as always, I’m interested in any feedback–big or small–so please don’t hesitate to reach out if you see something suspicious or flat out wrong.
11 December 2020
Early Access #9 is available. Here are the release notes:
This is the 9th early access release of the C# Player’s Guide, 4th Edition.
There were three major efforts that were completed in this update, and it might be the most substantial update we’ve had.
First, the book now accounts for all C# 9 features. Most of the actual C# 9 feature changes were in advanced, dark, corner cases and didn’t require any big changes. But there were several that are worth pointing out:
- Partial methods just got more powerful. The Partial Methods sub-section in Level 47 got revised.
- “Native sized” integers (ints that match the target hardware, for situations where you are interoperating with low-level code) were added. A section for this was added to Level 46.
- You can use
staticon a local method or lambda to prevent closures/capturing local variables. The Closures section in Level 38 changed to show this.
- If a lambda expression does not need a variable, it can now use a discard for the variable (Level 38).
- When you override a method, you can now specify a more specific return type (Level 26).
- When the compiler can infer the type, you no longer need to list the class name when using
newto call a constructor:
Point p = new (x, y);. See the new subsection called “Leaving Off the Class Name” in Level 18.
- Lots of new improvements to patterns, including the
notpatterns, as well as the
>=patterns. See Level 40.
initaccessors for properties, in addition to
set. These cannot be set whenever, but can be set in the constructor or in object-initializer syntax. See the revised section called “Object Initializer Syntax and Init Properties” in Level 20.
- Records are a new special type of class that is data-centric, with extremely compact definitions. A whole new level exists for records: Level 29.
- Top-level statements. More on that later.
Second, I made some rather significant changes to the internal visual design of the book, changing a number of fonts. I was able to increase the font size and reduce the page count (weird, right?), and every graphic designer I have talked to about it has suggested a serif font is better for long reading than a sans-serif font, which is what drove the change more than anything else. I suspect there are a few places here and there that didn’t get the appropriate font change. If something looks out of place to you visually, I’d love to hear about it. I’m using styles through and through, but there are a lot to manage, and it is easy to miss them here and there. I will still be going through everything with a fine-toothed comb at least one more time, but I could definitely use your eyes to help.
Third, I spent time getting an early version sent to the printer to make a physical copy. It takes time to get that going and to get a copy shipped, so I have yet to see the physical edition, but it should be available in the next few days. I’m generally expecting to get an updated physical copy every week starting now, to help track down those issues that only reveal themselves in print.
Now let’s talk about that top-level statement thing in more depth. C# 9 added a feature called top-level statements.
It allows you to ditch the whole
class Program, and
public static void Main(string args) and
just write something like
System.Console.WriteLine("Hello World!"); as a complete program. The compiler generates
Program class and a
Main method of sorts, so it is still technically doing the same thing. Just with less typing.
It is helpful for new programmers, because you don’t have to know what classes, namespaces, and methods are, nor
string. You can just start really basic. It is also helpful for everybody else too. I’m not sure
I’ll ever write another
public static void Main in my life. For large programs, this change has only the tiniest impact
on your overall code. But for small programs, it greatly reduces the amount of ceremony and pomp around creating a basic
As you may know from my mid-week email asking for feedback on how to approach top-level statements, I was very
conflicted on how to address this. I could just leave things more or less as they are and put a small blurb late in the
book that said, “By the way, there’s this other syntax,” or I could change the entire beginning of the book to allow
people to ease into C# better by using top-level statements to get going. It was a hard decision (and even now, I continue
to wonder) but I decided that top-level statements are probably the way to go. It definitely eases the learning curve
for new programmers, and while 99.99% of current C# code uses the traditional
Main entry point, future code will
likely slant towards top-level statements. So lots of the book was reworked to account for this.
There is now a note right at the beginning of the book that has you turn on a feature in Visual Studio (16.8) to make
using top-level statements easy to begin with. Level 3 (Hello World) got a pretty substantial rewrite, including telling
you to delete the contents generated from the template and replace it with a top-level statement. The Methods level
got some pretty significant changes as well. So if you’re past that, you might want to skim it. And the Enumerations and
Classes levels got some adjustments, mostly around where to place new type definitions. Finally, Level 33, which used to
be about namespaces, is not about namespaces, splitting your code into multiple files, and the traditional
points. Because methods created as a part of top-level statements are local functions, the section on local functions
was also moved up one level.
There is one important drawback: as the book currently stands, it assumes that you will have Visual Studio 16.9 in your hands. That is not out yet, and I was told by somebody who knows that it will not likely be released in December. Until it is out, you will have to enable the preview feature described in the note at the beginning. My initial thought is to delay the release of the book until Visual Studio 16.9 (16.x is Visual Studio 2019, if that helps avoid confusion with their double-versioning scheme) is out, probably in January or maybe February. I do still have the option of putting into the book something to the effect of, “If you are using a version before 16.9, go turn this thing on. Otherwise, you don’t have to do anything.” That would allow me to not have to wait for the final 16.9 release.
My decision about top-level statements is made, but it is tentative. I got a lot of comments (split fairly evenly) on what approach to take, and for many people, feelings were pretty strong. I’d be interested in hearing from you again now that you have a version to review in your hands. (Whether it changed your mind or not.)
The next big efforts are creating solutions to the challenges, updating the cover, and beginning the final, fine-grained revision pass (copyediting, indexing, checking that the sample code all compiles, etc.). We’re getting to the end!
4 December 2020
Early Access #8 is available, and the entire book is now there! I was able to finish the last nine levels (chapters), as well as the glossary and the tables and charts.
There are several big efforts still remaining:
- Update the book to C# 9.
- Get the website ready, including a few articles that the book calls out that don’t exist yet.
- Create solutions for all the challenges.
- Update the cover.
- Update the index.
The focus for next week will be on C# 9 features. I don’t know that it will be done by the end of Early Access #9, but whatever is ready will be included.
27 November 2020
Early Access #7 is available. This includes six new levels (chapters):
- Level 32: Namespaces
- Level 42: Threads
- Level 43: Asynchronous Programming
- Level 44: Dynamic Objects
- Level 49: Unsafe Code
- Level 50: Other Features in C#
That puts us at 46 of 55 total levels or 84%. It is 417 of 515 pages by page count (81%) though the revision pass that I am doing is cutting out pages in high numbers. The final page count will be under 500 pages.
20 November 2020
Early Access #6 is available. It is a nice feeling to have that done with most of the weekend still ahead of me to carry on with the book without pressure.
This includes 8 new levels (chapters):
- Level 34: Exceptions
- Level 35: Delegates
- Level 36: Events
- Level 37: Lambda Expressions
- Level 38: Files
- Level 39: Pattern Matching
- Level 40: Operator Overloading
- Level 41: Query Expressions
Level 33 (Namespaces) is still not ready, giving us 40 of 55 total levels or 72% of the full book by chapter count.
Of course, even when this revision pass is over, there will be plenty to do still, including updating the book for C# 9, creating solutions for all of the challenges, and updating the cover.
I think the guess of Late December seems quite reasonable still.
And since I have somehow turned these updates into updates about the kitten, too, you will be happy to know that he is doing great and growing up fast. (Still only gets to the litter box half the time, but he weighs twice as much as when we found him! He is now probably about five weeks old, and we have had him here for the last two.)
13 November 2020
Early Access #5 is now up. The earliest I have ever been, which is nice. But it comes at a cost: This is from only five days, all of which were workdays. So it is a small update.
This adds only a single level (chapter) to the book, though a second level was merged into it. So the book is two chapters closer to being done.
This also adds a partial solution for the Fountain of Objects challenges. I’m not done with all of them, but I am done with a few, so I’ve made those solutions available.
It also includes many small grammar and spelling fixes, many of which were reported by readers. Please keep the feedback coming, no matter how big or small!
Also, the cat seems to be doing good. He was not eating and not pooping, but he has been doing both, and after losing several ounces of weight, he has regained all of it and a bunch more. I think he’ll end up being fine! (Though I will also say he has taken up some time and sleep that might otherwise have gone into the book. But I don’t regret that for a moment.)
8 November 2020
I’m a day later than I’d like. We found an almost 3-week old abandoned kitten and have been trying to take care of it. That’s very time consuming, though I don’t regret it. Hopefully, he (we think) comes through okay. He seems lively and happy but isn’t eating as much as he should and hasn’t pooped in the 36 hours that we have had him, so we’re worried about that too. (Yes, we’re stimulating him.) We’ll take him to the vet tomorrow if he doesn’t start pooping and eating more.
Anyway… future releases can hopefully get back to Friday night or Saturday morning now.
Early Access Release 4 is now up on Gumroad and includes 7 new levels (chapters), along with the usual small fixes for typos and unclear sentences. This completes Part 2 and is also now 31 of 56 total levels. However, I will be going through the challenges in the level called The Fountain of Objects, which is the book’s most extensive program besides the final battle. I had wanted to do that for EA 4 but needed to abandon that plan. However, my initial attempt at a solution made me decide to restructure some of the challenges there. I did that to make them clearer and simpler. Putting together my own solution in the coming week may result in additional changes.
I have also revised my guess about when the book will be done to late December. I’m still hopeful it could be early to mid-December, but I keep pushing it out, and that makes me think I need to make a bigger adjustment. So I’m currently guessing late December, but Early Access releases will come every week until then, either way.
A final note: This week is the .NET Conf, and C# 9 and .NET 5 will be officially released. I was hoping to have the 4th Edition ready to go about right now, but I won’t be. You may find some of the sessions about C# 9 and .NET 5 interesting, and a preview of how The C# Player’s Guide will be modified to account for those in the coming weeks!
31 October 2020
Early Access Release 3 is now up on Gumroad, including two new levels (chapters) and some fixes for typos and unclear sentences. This includes a level solely focused on building some more significant programs, including Tic-Tac-Toe. (3rd Edition had a chapter called “Tic-Tac-Toe,” though this is substantially revised.) This release includes solutions to all of the challenges in that level since they are more substantial than others before it. (Eventually, they will all have answers.)
24 October 2020
Early Access Release 2 is now up on Gumroad, including eight new levels (chapters), some fixes to page numbering and XP, and other typos.
17 October 2020
Early Access Release 1 went up on Gumroad today: https://gum.co/oKNdk
I’ve set the cost at $9.95, but I expect that to go up as the book gets closer to completion. (The 3rd Edition’s digital version is $29.95, for reference.)
Keep these two points in mind:
- This is only Part 1 of the book. The other chapters need more revision before being included.
- This is digital-only. No physical book is included in this now or later. (A physical book will be available when the Early Access is complete. If you want a physical book, your best bet is to buy the 3rd Edition, which is already available, or wait a few more weeks for the 4th Edition.)
Anybody who joins the Early Access will get all other Early Access releases until the final release (as well as any patch releases I make after the official release). So this is an excellent chance to get it cheap if you’re okay dealing with a few rough edges here and there.
If you are willing to commit to putting some effort into reading it and doing the challenges, and providing thoughtful feedback, please email me. With a commitment to helping me make it better, I can get you a code for a discount on the book. An ally who will help me find the issues so I can fix them is worth more than the few bucks I’d get from Gumroad at this point.
Early Access Release 1 does not contain the entire book. It only has Part 1. That is the only part that has had a serious revision pass completed on it. More chapters will be added soon. But for somebody working through the book, they can get started on the first 100+ pages now and get the rest of the updates over the coming weeks.
I expect to put out a new Early Access Release with any changes, fixes, and improvements to existing content and add in the new chapters that have had a revision pass. This should happen roughly weekly on Friday or Saturday until the final release comes, probably in 4 to 8 weeks.
This is a big deal, and if you have any questions about what to expect with Early Access, feel free to contact me (email@example.com).
You can also track the progress of Early Access through this GitHub page: https://github.com/rbwhitaker/CSharpPlayersGuideEarlyAccess/.
With that, I’ll update my guess for publication to sometime between mid-November and early December.
4 September 2020
I’ve been making progress this week towards the first digital-only early access release of the book. I have at least another week of that, but it might be two or three weeks.
In my next update, I can post more numbers for percentage complete, as I have been cleaning up my backlog of items to do.
Here’s a high-level to-do list that I think is needed before Early Access:
- A revision pass through every chapter. (So far, I have done about 5 of 55-ish.)
- Reworking the quizzes throughout the book.
- Marking some sections as Side Quests.
- Deciding what to do about marking key points in the book as special (or deciding not to do this).
- Changing the order of some of the late chapters in the book.
- Some additions to the Try It Out challenges in the book.
- Making the cover say 4th Edition, even if it isn’t the final version of the cover.
27 August 2020
I was going along with pretty frequent updates for a while there and then stopped. But rest assured, I’ve put lots of time into the book in the meantime.
It is time for another update, though: I expect the 4th Edition of the book to be available in November of 2020 when C# 9 and .NET 5 are released.
As I was doing revisions in January, I began to find more and more things I wanted to change about the book. I ended up in a situation where I decided to significantly revise almost every aspect of the book. In some ways, the 4th Edition is almost a complete rewrite. Not exactly, but close.
So here we are, nearly eight months later.
I feel reasonably confident that the November deadline will hold this time, and the book will be much better for the delay.
I’ve also been considering something I haven’t done before: making a digital-only version of the book available in an Early Access format. It could be a good way to get some extra eyes on the book early on while also allowing people who want an updated version before November to have it. I am not yet committed to doing that, but it’s a distinct possibility. It will probably be at least a couple more weeks before that happens if it does happen.
As far as my percent complete that I was reporting, I was thinking today that I maybe should file bankruptcy on it. My next step is to do a lot of cleanup of my to-do list, and I’m tempted to just toss it and start fresh. I’ll let you know what I do in the next update. (I’m hopeful that updates can come every few days from now until publication to keep you all informed of the current status.)
1 January 2020
Currently there are 164 issues involved in the project:
- Done: 73 (44.5%)
- In Progress: 0 (0%)
- To Do: 91 (55.4%)
I’ve completed 26 tasks in the last couple of days, but I also added in 89 more tasks as well. (And that doesn’t include ones that got added to a later version of the book.)
But I hit a rather significant milestone today: all of the C# 8 content is now largely in place.
Roughly 60 of the new issues are in a “taking stock” category, which is stuff for me to go through the book and itemize what else still needs to be done before the official release. That’s my next step, and should knock out about 60 total items of the 91 left to do, but will also likely produce a number of other new items. Once that is done, the number of tasks being added to the project should flatten out quite a bit.
Estimated completion date is still late January 2020.
30 December 2019
Currently, there are 75 total issues involved in the project.
- Done: 47 (62.6%)
- In Progress: 1 (1.4%)
- To Do: 27 (36%)
While I’ve completed a lot more (approaching 2/3 of the way) I’ve also added in a lot more tasks. Many of these are small-ish.
Again, my latest projection for the book release is January 2020, but probably on the late end, with a small chance of flowing into February. As we get late in the process, I start ordering physical copies to see what still needs to be tweaked, and that is a longer feedback loop.
More to come soon!
15 December 2019
The 4th Edition of the book is coming along. New tasks come up every day, but also every day, tasks get checked off.
Currently, there are 62 total issues involved in the project.
- Done: 27 (43.5%)
- In Progress: 19 (30.6%)
- To Do: 16 (25.8%)
A big part of the “In Progress” ones are related to the rewrite an/or addition of five different chapters, and they’re (unfortunately) moving through the pipeline right now in sync with each other. When they go, they might all go together.
Outside of work, all of my focus and attention is currently going into this 4th Edition.
The earlier numbers are concrete; they are 100% accurate of the current situation. This next number is a wild guess. My best guess is that the 4th Edition will be sometime in January of 2020, so depending on your time table for learning C#, waiting until the 4th Edition arrives might be worth it.
If you have any questions about the state of the 4th Edition, don’t hesitate to contact me.
Also, if you have some experience with C# in the past (like if you bought the 3rd Edition and have been through it) I’d love to get some reader feedback on the new chapters in the works for the 4th Edition. The time frame is kind of tight. Probably over no more than the next 10 days or so. Let me know if you’re interested. (It won’t be the whole book, just the specific new chapters, so it won’t be self contained in terms of learning. That’s why I’d ideally like to get people who have already been through the 3rd Edition or have some familiarity with C#. But I’ll take whoever is interested right now.)
Unfortunately, I don’t have anything to offer, in the way of payment or reward for helping out in this way. (Other than you get access to a draft of the content before most people do, in exchange for some feedback from you about what’s working and what’s not.)
Expect more updates as we get closer to the publication date!