I’ve been at ThoughtWorks for 12 years. Who would have imagined? Instead of writing about my reflections from the past year, I thought I would do something different and post twelve key learnings and observations looking back over my career. I have chosen twelve, not because there are only twelve, but because it fits well with the theme of twelve years.
Stairway to XML
XML has been part of the SQL Standard since 2003, and is essential for
any DBA because so many of the dynamic management views return XML data.
Now that the industry is more used to data defined by document markup,
it is becoming more important than ever for Database Developers and DBAs
to understand the technology and to know where it makes sense to use
XML. In this book, originally a series of articles on
SQLServerCentral.com, Robert Sheldon flexes his talent to make the
complicated seem simple.
Unhandled exceptions are a bit of a misnomer. In .NET, every exception is handled. By the time you access the specifics of an error in your Try-Catch block, the Framework has already analyzed the problem, built a structure to contain its details, examined the stack trace, and used reflection to pinpoint the location of the error, among other mundane tasks. In short, when errors occur, .NET serves them up to your code in a neatly packaged, highly examinable data block.
.NET Core placed high in a web-dominated ranking of development frameworks published by CodinGame, which provides a tech hiring platform.
Frameworks: React is 2021’s most sought-after framework
Node.js, React and .NETCore are currently the most popular frameworks amongst developers.
React is the most sought-after framework: 59% of tech recruiters are on the lookout for developers who know React.
Developed by Microsoft’s Research in Software Engineering, Code Contracts provide a way to convey code assumptions in your .NET applications. They can take the form of preconditions, postconditions, and state invariants. In C# Code Contracts Succinctly, author Dirk Strauss demonstrates how to use Code Contracts to validate logical correctness in code, how they can be integrated with abstract classes and interfaces, and even how they can be used to make writing documentation less painful.
/// <summary>
/// (Syntactic Sugar) Checks if the given value is among a list of values or not.
/// </summary>
/// <remarks>
/// This method is for syntactic sugar. What it actually does is to allow developers to wrtie a code like this
/// <code>
/// xVariable.IsIn(MyEnum.Value1,MyEnum.Value2)
/// </code>
/// Instead of these codes:
/// <code>
/// new []{ MyEnum.Value1, MyEnum.Value2 }.Contains(xVariable);
/// </code>
/// Or more commonly:
/// <code>
/// xVariable == MyEnum.Value1 || xVariable == MyEnum.Value2
/// </code>
/// </remarks>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="list"></param>
/// <returns></returns>
public static bool IsIn<T>(this T source, params T[] list)
{
Func<T, T, bool> compare = (v1, v2) => EqualityComparer<T>.Default.Equals(v1, v2);
return list.Any(item => compare(item, source));
}JS Is Weird
JavaScript is a great programming language, but thanks to the fact that its initial release was built in only ten days back in 1995, coupled with the fact that JS is backward-compatible, it's also a bit weird. It doesn't always behave the way you might think. In this quiz, you'll be shown 25 quirky expressions and will have to guess the output. Even if you're a JS developer, most of this syntax is probably, and hopefully, not something you use in your daily life.
With the release of Free Style 1.0, I figure it's about time to write about Free Style - how it works, why you'd want to use it and little introduction to CSS-in-JS. This has been a long time coming, with my first commit to Free Style over a year ago, and the first commit to Free Style in its current form 10 months ago. This is not a blog post designed to sway decisions - as always, you should use your own fair judgement.
