Finally the book is here! I’m biased, extremely biased about this book, and for good reason. We met Renda and the Madrigals when our daughters went to the same kinder garden, elementary and middle school. We’ve vacationed together and have spent time together as families and still go out together every couple of months.
So you can say we know them well.
When we found out that Renda was writing this book we couldn’t help but be happy. Writing a book is such an endeavor, and a topic about mindfulness and families is a rare thing to find, and this book is unique in that way.
We have been happily part of Renda’s mindfulness sessions as a family and can attest to their effectiveness. One of the first things that you notice is that you do practice, well, as a family! That awareness in itself, that you’re doing something you like with the someones you love makes all the difference. Besides, Renda has a unique way of creating an ambiance, calming you down, focusing you in the moment, in the now, in the present.
So, if you’re into mindfulness and want to share this experience with the rest of your family, go ahead and get a copy. Got mine. On Kindle.
With a large percentage of vaccinated people in the US, and the number of COVID-19 cases dropping dramatically in our county in California, it seems inevitable that some time in the near future we’ll have to return to a physical office, if only partially. For those of us with kids at home, there’s also a large possibility that they’ll have to return physically to school.
Last year I took the plunge and got a one-year subscription to Zoom, and our family meetings and community service have benefited from it. We schedule at least three meetings during the week, but it seems all this will be coming to an end. Zoom has proven resilient and useful–I have to provide an attendance list for about 25 kids in a class, and the reports are great. But being candid, I won’t miss it a bit once we’re able to meet people in person. So nope, I won’t renew.
Transitioning (as a family and not as an individual) will be stressful. There is some anxiety kicking in because of the unknown.
Regardless, it is concerning that other countries are still in the thick of it, and my thoughts go for those friends of ours with family in India. We’ve had the misfortune of losing three uncles and two aunts, in the span of three months, one just last week, albeit only one of them to COVID. This is on my side of the family.
If you’re in the US, how are you coping with the transition?
This is my Lightning Talk for CPPCON 2020. I’m super grateful to Chris Ryan for posting it on LinkedIn.
Quality C++ documentation is abundant…as long as it is in English. If you’re a Spanish speaker your options are limited. This talk is about my experience in bringing es.cppreference.com, the Spanish companion site to cppreference.com, up to date to enable Spanish-speaking C++ lovers and enthusiasts a quality experience when learning C++…en español.
Many years ago I read a follow-up book to the seminal Design Patterns book by The GoF, called Pattern Hatching: Design Patterns Applied by John Vlissides. He kept a homonymous monthly column in C++ Report, a magazine now defunct. One of the things that called my attention is that he mentioned that keeping on with design patterns was a labor of love.
Before his passing, he was kind enough to review an article that I intended to publish on Pluggable Factory and gave me very valuable feedback, as well as feedback on using the nifty counter technique–originally in the C++ ARM and then in John Lakos‘ book, Large Scale C++ (first edition)–to implement a variation of Singleton.
To me, John was an inspiring figure to give to the community without expecting anything in return, and hopefully the effort of translating C++ documentation to Spanish will enable others to learn and love this programming language that has given me so much.
Three-way comparison (aka “the spaceship operator <=>) is a cool new feature in C++20. While the usage is simple, the documentation is not :-). Strong, weak, partial ordering…concepts, more concepts, type traits, and so on.
Documentation a long time in the making, but I finally had a good couple of days working on it. There are some examples missing–ditto in the English version–but nonetheless much needed documentation. You can find it here.
La comparación de tres vías (también conocida como “el operador nave espacial”, <=> ). Mientras que el uso es simple, la documentación no. Ordenamiento fuerte, débil, parcial…conceptos, más conceptos, rasgos de tipo y así sucesivamente.
La documentación tomó bastante tiempo, pero finalmente tuve un buen par de días para trabajar en ella. Hay algunos ejemplos que faltan–lo mismo en la versión en inglés–pero no obstante, se necesita mucho la documentación. La puedes encontrar aquí.
I also own a 2019 MacBook Pro (Intel Core i9, six-core), and informally they’re on par in terms of performance, but Geekbench reports, the Mac mini M1 beating the MacBook Pro hands down.
I’ve been running versions of IntelliJ IDEA for Apple Silicon and CLion for Apple Silicon. Startup time almost instantaneous from a cold boot. Kudos to Phil Nash, Anastasia Kazakova and team for these great tools.
It took around 3 weeks to receive it since I ordered it, but it was worth the wait–and I wasn’t in a hurry. If you can get your hands on one of these, or are undecided, highly recommended.
This was my favorite session. I must confess that I’ve seen it three times, and had the time to go slowly over the topic discussed: performance.
Emery Berger needs no introduction. Just check his LinkedIn profile, but just in case, his credentials are at the beginning of the session and just the fact that the CPPCON organizers scheduled him for a plenary session is telling: He’s got the goods.
What made this session useful and memorable? On one hand, Emery supports the topic of performance taking a meticulous approach supported by sound math, statistics, data, you name it. At the end of the post I add references that are mentioned in the session.
Chillax, have a mojito
Emery starts the session with a simple example: performance of a given system in the ’70’s, cool ’80’s, and today, but soon things get super interesting. In the past, you gained performance just by…upgrading your computer, right? Of course! Who doesn’t remember those Gateway 486SX computers with 4MB of RAM (and don’t make me go to 386SX, 80286, 8086…)
Well, with the advent of multicore/manycore processors, things changed, and for the better.
Gains in performance cannot be stated by “I ran it once and it ran better”. Given two systems, A and A’, if A’ performs better and making a claim, what is the reason? Our typical approach is to find opportunities for better code, but why? It shouldn’t be black magic, right?
So, without spilling the beans, this is what you will learn from the session:
Variance when there are factors that may affect performance
Data Layout (from code to how it’s really laid out in memory)
Link order and its impact on function addresses
Environment variable size (moves program stack)
Running a program in a new directory and its impact on layout
Moreover, Emery introduces causal profile and Coz, and how to approach a performance problem. What he exposed reminded me of Control Theory with a feedback loop. I asked Emery in a follow up Q&A about the difference between BPF and Coz, and he mentioned that BPF is an observing tool, while Coz is a predicting tool. I would think they would be a great complement to each other. On verra.
In this section of the talk you’ll be introduced to:
Experimentation and what slowing down a component reveals
Latency and throughput
My favorite reference was Little’s Law, which I have used exactly twice in previous projects. A specific resource where it is mentioned–and used–is in Windows Server 2003 Resource Kit: Performance Guide.
Hopefully I got you interested in this session. If you have an hour to chillax with a mojito, I encourage you to check this session. You’ll derive hours of satisfaction following up the papers and putting into practice what you learn.
Word of the Conference
Many of the sessions, such as Emery’s plenary session, and Herb Sutter’s capstone plenary session, make use of the word incantation. Presenters use it to present a non-apparent solution to a given problem. It seems that every CPPCON conference I’ve attended there’s a catchy phrase. We’ll see what next year brings.
Arthur O’Dwyer’s session is a lap around the concurrency facilities present in C++, starting with C++11. He starts the session with a gentle introduction to concurrency and parallelism pre-C++11 and walks you towards the memory model present in Modern C++, then he proceeds by presenting threads, joining threads, mutexes, scoped lock, atomics, shared_mutex, condition variables, counting semaphores, latches, barriers, promises, futures. You get the idea. He goes further by introducing usage idioms for some of these mechanisms.
Ay Chihuahua, Singleton again!
I mentioned in a previous post that Singletons are posible in Modern C++ using std::call_once and std::once_flag. That is explained here, too.
A cursory view of std::memory_order (or if you prefer Spanish, std::memory_order) will give you more details on the different relationships and their formal definitions, synchronizes-with being, IMO, the easiest.
As a side note, if you want a holistic approach for concurrency in C++, be sure you check Anthony Williams’ book, entitled C++ Concurrency in Action, 2nd Edition, and it’ll be a great complement to Arthur’s talk.
I like the fact that CPPCON is devoting time and speakers to Back to Basics sessions. I think they’re much needed and help bring novices or engineers coming from other languages into mainline C++ programming, helping them to navigate intricate–or sometimes historical–aspects of the language and are time savers, or simply help pointing in the right direction.
I also like the fact that Arthur does not make the session complicated. It is a nice introduction and leaves it up to you to dig up deeper on each of the facilities.
The Blue/Green Pattern
I like the last couple of slides defining this pattern. When sliding in new versions or services/microservices/configurations, is important to do it right. In my particular case, this was the highlight of the session and wished there had been more on it, but alas, Arthur was pressured with time. The technique is what I’m interested in, particularly since he mentioned C++20.
In a nutshell, I liked the approach that Arthur had. Easy going, reaching the Goldilocks principle: not too deep, not too shallow, just right. Got an hour to spare? Jump in!