trust-fund-babies-no-good

The “Basic Income” Trust Fund

I’ve been toying around with the idea of setting up small trust funds for my potential future grandchildren. My objective is to provide them with a base-level amount of support, not to make them filthy rich. The trust would require a university degree and a part-time job for anyone receiving money. I would target about half the median income, roughly $2,000 per month.

Running an analysis on cFireSim we find that we would need $560,000 invested in at least 75% equities to have a 90% chance of success over a 30 year period. This drops to around 75% chance of not exhausting the trust over a 50 year period.

So, we need a little more than half a million for each beneficiary of the trust. Assuming that you have 3 kids who have 3 grand-kids, you would need to support 9 people or so. 9 x $560k = $5,040,000. Not exactly chump change. The good news is that we have the power of compounding and plenty of time.

Assume that you are 20 years old and have kids at age 30. They have kids at age 30, and your grandchildren must be 20 before they receive distributions. That’s a waiting/accumulation period of 60 years.

If you earned the market average 6% after inflation (9.7% growth – 3.5% inflation ~= 6%), you would need a lump sum of $152,784 today to meet your target. Not exactly chump change, but much more reasonable. Again using cFireSim, we can estimate that at an 80/20 allocation, we would need to put away $1,000 per month for 60 years . In the best case historically you end up with $9.5 million in the trust while the worst case is around $3 million.

While saving $1,000 a month isn’t easy to do, especially on top of saving for your self, it can be incorporated into your other retirement plans. Your assets at retirement, life insurance payout, any future inheritance, or your Roth IRA could all be combined together to make this a very workable plan.

Go run some numbers for yourself. Perhaps this scenario is too aggressive. Nonetheless, the idea is an interesting one.

gates_speedway_day-350

A Review of my University of Texas Academic Career

After having completed the requirements for the Bachelor of Computer Science at the University of Texas, I feel it is a ripe time to do a quick review of the classes I took for my degree.

Freshman Year

CS 315, “Algorithms and Data Structures”: This class was the second of the required “entry-level” courses at UT. I found the class adequately covered data structures  and equipped one well for an interview. I took advantage of using Lisp, which first introduced me to functional programming. We worked on an interpreter which could take a set of functions and known variables, and solve the entire system if possible. Additionally, you also end up implementing Dijkstra’s, A*, and other path-finding algorithms. However, I didn’t find the lectures very interesting.

CS 313K, “Logic, Sets, and Functions”: This was the introductory logic course. The first part of the course is very easy and covers boolean logic. The second part covers sets and proofs. I got a little behind in the class since it was my freshman year and found induction proofs to be difficult at first, and I didn’t enjoy them. However, they prove extremely useful when planning and implementing recursive algorithms. Set logic is also very useful and can be easily implemented in languages with set notation (Haskell, Python, etc).

CS 378, “Autonomous Vehicles in Traffic”: This class was and was one of the Freshman Research Initiative courses offered at UT. Basically, we learned about Marvin, the University’s autonomous car. You get rudimentary C++ knowledge and implement a road-detection using OpenCV. The class was pretty easy in my opinion, and you were exposed to various frameworks such as ROS and OpenCV. It’s worth taking if you haven’t been exposed to anything I mentioned above.

CS 336, “Analysis of Programs”: This class built upon CS 313K, focusing on induction proofs and dynamic programming. The class was a bit tougher but not impossible. The lectures were fairly good, but I personally don’t find the logic types of classes to be extremely engaging. Again, a decent class covering a good section of theory.

CS 439, “Computer Organization and Architecture”: This was the first of the “Systems” classes at UT. You are thrown into working with C quite early and focus on how the processor works. The first assignments are essentially optimizations using bit manipulation, but this class had one of my favorite labs, the “Bomb Lab.” In this particular assignment, one had to enter a series of code phrases into an executable provided by the instructor. The catch: every time you entered an incorrect code, the bomb “exploded” and you lost points. You had to disassemble the program and read through the Assembly to find the correct input. One of the most useful classes at UTCS.

Sophomore Year

CS 344M, “Autonomous Multi-agent Systems”: This was a research oriented class which dealt with managing multiple agents in a distributed system. I still have the textbook, as it has lots of interesting material ranging from consensus-building to efficiency to individual decision making. We read some fascinating research each week and wrote responses, I’ll list some of these publications at a later date. The final project is actually building a virtual soccer team of independent, but collaborating agents to compete in the “RoboCup.” Interesting stuff.

CS 439, “Principles of Computer Systems”: Also referred to as Operating Systems, this class is one of the most challenging in the entire curriculum. However, in my opinion it is also the most valuable. We build off 429 concepts and learn about the low level implementation of algorithms. First we implement semaphores, mutexes, locks, and multi-process scheduling in a teaching OS called Pintos. Then you move on to implementing system calls, memory management and paging, and finally a file-system. My team met for almost 4 hours every day to work on the project. It was hard as crap, but I learned more in this class than any other.

CS 345, “Programming Languages”: I took this class with Professor Cook, who first introduced us to Haskell before going into detail about scoping, environments, and expression evaluation. You end up implementing a JavaScript interpreter in Haskell (how cool!). This was also one of my favorite classes.

CS 378, “Algorithms and Complexity”: I took this class with Prof. Zukerman and did not like it that much. I felt the lectures were straight out of the book, and the tests had nothing to do with the lectures. I got a 68% in the class and it was rounded up to a B+ (!). Haha. Beware this class, I believe it is renamed CS 331. We basically covered the same stuff as in the other logic classes and I remain unimpressed by the reason I was required to take it (namely, graduation requirement changes).

Junior Year

CS 371M, “Mobile Computing”: This is an interesting “app” development course taught by Mike Scott. You cover the libraries and implementation methods for working on an Android system. You get out what you put into this class, so I would advise implementing a slightly more difficult project idea, since you will learn more. I built an app for meeting people near you studying. I implemented Facebook authentication, a backend server in CakePHP, an adapter for integrating data between the device and the server, and implemented push authentication. I thought it was a good course, and would recommend.

CS 350F, “Operating Systems”: I just finished this class… A bit of a letdown. We covered a subset of 439 and in less detail. The professor and lectures were a bit unorganized. I found the class to be kind of pointless since there wasn’t anything new for me to learn. Wouldn’t recommend.

CS 375, “Compilers”: Yes, Prof. Novak’s lectures are quite dry, but I still enjoyed writing a compiler. I couldn’t really tell if this was a tough course, or if I just have terrible senioritis… You only have to work like 2-3 solid days for each of the 5 major assignments, and in the end you have a Pascal->Assembly compiler. Pretty sweet. I would recommend this to stretch your programming and debugging ability, as well as your patience.

CS 373, “Software Engineering”: One of the most practical, pragmatic courses offered at UT, taught by Prof. Downing. In this class you work with Python, Django, and SQL to build a web application in a larger (6 person) team setting. This is a valuable class, especially for anyone who hasn’t worked on such a project before. Prof. Downing is very good and clearly cares about his students, which is an added bonus.