Differing Viewpoints

March 10, 2019 ~ jgodbou ~ Leave a comment

Today, I wish to discuss the internal culture of the U.S. and China. This comes from recent talks between my wife, some of my coworkers, and I.

A common discussion my wife an I have is on the separatist bent of Taiwan and Tibet. My wife is continually irked by people saying their from the country Taiwan, as her upbringing tells her that Taiwan is a province of China. Growing up in the United States I grew up to believe that Taiwan should be a country.

The common argument she asks is what if Vermont (or Hawaii) decided to leave the United States. I shrug this off and say that if a majority of Vermonters decided to leave the U.S. then we should let them, though history does not vindicate this answer. There was a separatist movement in the United States in the mid 1800’s, and the federal government wouldn’t let that happen. One would imagine that the U.S. government would have much the same action.

The U.S. is a republic, we vote for who’s in office as a collective. If we allowed California to leave because Trump was elected (or Texas because of Obama) then why bother with this collection of states at all?

To further drive at this point, I was talking to friends at a math conference about evolution being taught in school, and they asked the question: What if the other side gained power and required creationism be taught? It’s a tough question, maybe laws should be decided at the lowest possible level of governance, states should be given most of the power, and we should question when the federal government starts dictating terms that states should otherwise handle.

The argument that this impedes social change is not lost on me, and the world is imperfect. But again, if you agree with Obama having sweeping presidential power, you must then deal with Trump, you don’t get to give power to only your friends.

Note: This runs counter to China, where the federal government tries to retain all power. But different countries have different values, each of which has evolved over thousands of years.

In the U.S. we believe that democracy is important. To a large degree, we believe that personal autonomy and civil rights are key to what and who we are. Cambridge just passed a chopping down tree ban, my personal view is it’s my damn tree and I’ll chop it down if I see fit, who is the town to tell me not to? Now we must temper this with a need to live together, you can’t go around chopping down all of trees as we need to breathe air (and trees help with that). I should be able to send messages to my friends without the state reading them (thanks Signal). As Benjamin Franklin said “Those who would give up essential Liberty, to purchase a little temporary Safety, deserve neither Liberty nor Safety.”

Chi Wang in the South China Morning Post had an interesting article stating China had no use for a democracy. This runs counter to my world view, shouldn’t everyone want a democracy. Talking to my wife, she agrees (at least in part) with this article. The internal cultural of a democracy is just not there, it wouldn’t fit the population. This will probably leave a bad taste in the mouth of most American readers (as it does for me) but it’s a worthwhile thing to think about. When discussing national safety she would completely disagree with Benjamin Franklin, it’s the job of the government to keep the population safe, the government knows best and if this requires giving up personal freedoms so be it.

I’m interested to see where on this divide my daughter lands.

img_20190303_152315

The Zombie Bug

March 2, 2019March 2, 2019 ~ jgodbou ~ Leave a comment

This was not a fun week.

Why was it not a fun week? Four bugs I thought I finished came back, I call them zombie bugs. The bugs you thought you had finished that just won’t die. I will start by discussing each of the bugs, what made them a problem, and how to move past.

Failure 1:

Most large scale systems will have to communicate with third parties. If you work for hotels, there is a standards committee that meets and describes data formats that a hotels customer retail systems will send to back end booking systems and to third party planner systems. If you work on airlines systems, IATA and ATPCO have a set of rules that describe which fares are available when, they each have a format, and every company must be able to read these in order to price and validate the price of a flight. I.e. you need a lingua franca.

How records are laid out today are NOT how records will be laid out tomorrow. Things change. The standards body meets (i.e. ATPCO) and decides record FOO needs field BAR, and so the data they will send changes. Your system must now support records of FOO containing field BAR. But wait, there’s more! You must also now how to read all the pre-BAR records of type FOO… Here’s my first mistake, I enabled the new, without keeping the old…

Lesson: Always remember backwards compatibility.

Failure 2:

Trying to update records is hard. Standards committees dislike change, and if they can pigeonhole a new field in an old system, they will. Just because a field is a match field today, doesn’t mean it won’t be an order field tomorrow.

Lesson: I don’t know how to catch this bug. I discussed it with a very senior developer, I wrote tests and I thought about it. Sometimes you’ll miss something, always try to be learning.

Failure 3:

I was given a sub-task on a larger task, an old bug that should be fixed, but is so rare it shouldn’t be much of a priority. I read the comments, and was confused (sometimes code is confusing). So I asked the person in who just gave a talk on the related section of code, and they gave a suggestion. It turns out, one of the comments on the bug is to not use that suggestion… I didn’t understand this section of code, and his reasoning made sense, so I followed his suggestion.

Lesson: If I would have asked the person who made the bug to review the CL, it would have been caught. If I understood what was going on, it also would have been caught. Don’t try to be fast, don’t try to avoid understanding. There’s a reason to do things correctly.

Failure 4:

I was given a task, and I wrote the code, and I submitted the CL. Generally, people want the code out soon, I was asked when it will be out, so I made the config changes and sent it out ASAP. As it turns out, the desire wasn’t to have it defaulted on, just test-ably on.

As a sub-failure, the code didn’t work properly (though I have no idea why, I even wrote tests for the failure seen, coding is hard…)

Lesson: Communication, do this more, make sure what you think they want is what you want.

Overarching lessons: Communication is key. Whether it’s sending a CL to the right person, or really understanding the desires of clients. You will never understand a whole system, if the system is large enough you may have to work in some mild state of not knowing, but you should still know who knows and ask them for help.

These kind of weeks happen. Learn, adapt, be grateful for people who help you learn, and continue.

img_20190227_194801-1 — And always spend time with the little one.

Teaching Philosophy Statement

February 17, 2019February 17, 2019 ~ wenjingtwins ~ 1 Comment

“Teaching with Love and Dreams” —–Wenjing Liu

“Best instructor in UMB”
“I expected to get a C in the course at first, I got A- finally. Thank you for everything! I would have done very poorly in this class without you. Good luck with everything”
“Very responsive via Email, explain different types of problems, review questions to help prepare for exam, explain things in simple terms”
“Very dedicated to student learning”
“She was enthusiastic, funny and nice”
“She is the best…..” I told my husband to stop reading my students’ comments.
“Your students always love you and your class, you are really a great teacher.” my husband said looking at me.
“Of course! If I am mute, I can still teach well.” I said to him happily, proud of myself.
“I believe that! what is your secret to be a great teacher?”
“Good question! You will know the answer in minutes.”

This is my dialogue with my husband. Here I also want to share the secret with you about how to be a great teacher. First, you really love teaching, and then you know how to trigger students’ inner motivation, how to design syllabi and lecture notes effectively, and how to keep students staying on track. Last, teaching with a big dream.

Teaching with your love. It is hard to tell how much you love to teach, but it is very easy for your students to measure. It is your enthusiasm, your passion! During my first class in America in fall 2013, I taught Finite Math at UNH. In my class, when I had trouble communicating with the students because of my broken English, other students jumped up and translated what I was saying or what a student was asking me. Nobody complained about my English, because they could feel my passion on teaching and enjoyed my class. Sometimes, students went back home earlier for holidays, so only few students showed up. I still taught them with my full passion like everybody was there. In addition, I teach in my own way. I have a happy, funny personality, so I will tell students a quick joke to refresh their brains when they feel tired or before I go over an important result. Sometimes I will make some funny action to make students happy and focus more on my lecture. As a result, they think math is a more fun and interesting course, and they enjoy and love my teaching.

Triggering students’ inner motivation. It is challenging to trigger students’ inner motivation, but there are four ways I use to have students learn math. One way is to tell them how math relates to their dreams, how math is useful to their dreams. Most students do not pay more attention to math because they think math is not their major, and the school forces them to learn. Students from Business, Computer Science, or even English just want to get the required credits. I will tell them, if they really want to do very well in their field, they need to have a very strong math background. They not only need to study the math courses the school requires, but also they maybe teach themselves other math courses which are related to their respective fields in the future.

Another strategy is to make students have faith in themselves. During my class, students could get bonus points if they answer my questions correctly, which makes them excited and they more will involve my class. Also, I encourage students to keep learning. For example, One student does not know what the value of the function f(x)=x2 at x+h is. I will ask him what f(1),f(2)are, I will be very excited if his answer is right and encourage him to follow me, then I will ask him what f(🙉),f(○)are. If he answers f(○)=○2, I will keep asking him, what happens if I fill x+h into ○. In this way, he finds the answer. The key is making him think he figures out the answer by himself so he feels he is very smart. Thus, he slowly starts enjoying more math.

The third way is to help students to get over their math anxiety. Some students are ready to take a math course and they want to learn it well, but they have an atrocious math background. I will tell them that is ok, that is why I am here. I will teach them quadratic formula if they forget it, I will teach them the basic formulas if they can not remember it. I will help them recall everything if they need it! After hearing this, students have more confidence for the course.

The last way is to be on the students’ side. For example, Some students really do not like math. I will say: “Some of you may do not care how useful the math course is, you just want to pass it, that is all. I understand you. What I want to say is you paid MONEY for it, so please get SOMETHING from this course!” When students make mistakes, I will say: “ I also made the same mistakes when I was a students.”

Design syllabi and lecture notes. To have an effective class one needs to design the syllabi and lecture notes well. The core part of a syllabus is the course goals and assignments. I will describe mathematics topics in each unit or section clearly and tell students which goals will be the basis for student assessment in the course. Homework, quizzes and exams will help them achieve these goals. In my opinion, mastery of material is obtained by working through problems from homework or other practice problems, assignments, and actively discussing these solutions, both right and wrong. There will be a lot of practice problems every week in every course I teach. I make course policies so each student can stay on track.

In addition, I carefully prepare and present the material such that students can understand the material better. “Which material might confuse the students? What kinds of questions might they have? How can I make them understand the topics better?” I always ask myself these questions when I prepare my lectures. I always focus on the topics that will confuse the students. How do I prevent confusion? Usually I will use the following four steps to avoid this confusion. First I will start by recalling something related the topic to warm up; from easy, to hard, to the topic. For example, taking the chain rule I will start by looking at the composition of functions. After explaining the topic, I will give different type of examples to make students understand them better, we may start with simple functions being exponentiated to complex functions including sins and logarithms. I will then ask students to do more problems in class, the ones who answer correctly on the whiteboard will get bonus points. Finally, I will give them assignment to practice and make sure students completely understand the topic.

Keeping students staying on track. I usually use inquiry-based learning in my lessons. For example. If we are talking about derivatives, I will try to discuss a toy model, like a student walking from their apartment to a classroom, and asking the the exact velocity as they walk. We start by assuming a strait line with average time, but then add complexities like stopping at an ice cream stand so the average velocity isn’t the true velocity during the trip. This not only engages the students, but we try to discover the derivative together. Also, I encourage my students to ask questions and tell them that there is no such thing as a stupid question. Thus, they could follow my lecture very well.

I also keep track of the students’ grades and participation in class. If I see them under-performing, I try to meet them after class and understand why they are stuck. Then I help them to get over the trouble. During office hours, I go over the material slowly and carefully, focus on the students’ needs. In addition, I also send them to useful resource, such as, tutor center, online videos, school counseling depends on the issue.

Teaching with dreams. I read my course evaluations and try to figure out how I can improve. I also keep track of the difficulties that my students had and what confused them, then pay attention to those when I teach this course next time. I also learn from other great teachers. Hopefully, I become a better teacher.

I am also curious of new ways to teach. For example. I usually teach classes in a traditional lecture model, but when I was a TA I worked in a flipped classroom model where the students watched lectures before class and class time was used to help them work through problems and understand the class at a deeper level. I found that the students understood the material better. I would like to implement this type of learning experience for my students in the future.

My final goal is to be a great educator. I hope, one day, I can share my ideas about teaching with other teachers by papers, videos or books.

Conferences With a 3 Month Old

January 25, 2019 ~ jgodbou ~ Leave a comment

Last week was a rather important week in the year of the mathematics community. The Joint Math Meeting, the meeting sponsored by both the AMS and MAA was held in Baltimore Maryland. For the unaware, this is the largest math conference in the world, thousands of mathematicians come from all over the world to discuss math research, find jobs, and eat cake.

As my wife is a graduating Ph.D, we went. Going to the meeting involved a 7.5 hour train ride from Boston’s Back Bay station to Baltimore’s Penn Station. For the whole trip, are little one either took one of our seats, or you could find one of us walking up and down the train cabin holding her. Really, it was a great choice, she either slept or we could walk, the WiFi was surprisingly good, and the seats are fairly comfy.

Usually my wife and I book an AirB&B, it’s cheaper and you get a decent apartment, but with a little one we decided to stay in a hotel. This means we got a crib! The crib is sadly very deep, so we ended up just taking the mattress out which worked much better.

Pro tip: Bring some toys and the mobil, it’ll make the place seem a bit more like home, and give your little one something to do for a few minutes. I know it’s a lot of stuff, but do it.

The days tended to be: go to talks or answer puzzles in the exhibit hall, dinner with friends, then the rest of the night is Lyra’s. To be honest, I felt bad not spending more time interacting with the little one… On the plus side, the JMM had a room reserved for nursing mothers, not many people seemed to take advantage but it’s nice that conferences are doing this now.

IMG_20190118_105517 — Wenwen, Lyra, and Conway

The way back we took the Acela, it only saved 1 hour but the chairs are nicer. It was harder to walk with Lyra as the train is much faster, but we were able to a little. \

So You Want To Parse Some Lisp

December 31, 2018December 31, 2018 ~ jgodbou ~ Leave a comment

Note: So, you’re a Lisp hacker interested in my Lisp-parsing discussion. You say to me, “I have slime, I have meta-dot, I don’t need your silly parser”. But what if you have a large codebase? What if you want to search through it over the web? What if you want inner bindings not stored in the who-calls database? On to our post.

Part of the blog last time was a discussion of parsing Lisp code; in this blog post I wanted to discuss some more advanced lisp parsing. The parser for let is simple as we know where the bindings are, and we know where the body is. More than that, we also know that the bindings will be independent—this isn’t let* after all—so if I compile

(defun hungry (fish)                                                                                                                
  (let ((fish 1)                                                                                                                    
        (fried fish))                                                                                                               
    (print fish)                                                                                                                    
    (print fried)))

and I call (hungry “salmon”) I will get:

salmon

printed to the repl.

As any lisp hacker will know, there are more-complicated forms. Today I wish to talk about the dreaded labels form. To invoke the full power of labels, let’s look at an example:

(defun func ()                                                                                                                      
  (labels ((print-one (print-two-p)                                                                                                 
             (print "1")                                                                                                            
             (when print-two-p                                                                                                      
               (print-two nil)))                                                                                                    
           (print-two (print-one-p)                                                                                                 
             (print "2")                                                                                                            
             (when print-one-p                                                                                                      
               (print-one nil))))                                                                                                   
    (print-one t)                                                                                                                   
    (print-two t)))

Here we have a function ingeniously called func that takes no arguments. The first thing we do is specify a labels form and use that to create two local functions, print-one and print-two. Each takes a boolean parameter and print either 1 or 2 respectively, and then call the other if the input parameter was true. Finally, in the body of the labels we call print-one and print-two.

Awesome. next, let’s look at the parse tree:

Wow! Let’s dig in, but remember we read in infix.

We first see a defun form which is simple enough (see the hyperspec http://clhs.lisp.se/Body/m_defun.htm). The first element is the function name, func. This is a top level binding. it’s already stored in the who-calls database, and life is good. We know that the second element, the lambda-list, is empty, and the remaining element is the body. That was simple right?

Next, we get to the labels form, the meat of this tree. We go to the handy-dandy hyperspec for labels (http://clhs.lisp.se/Body/s_flet_.htm) and see we will have a list of locally bound functions first, followed by the body. We also read:

labels is equivalent to flet except that the scope of the defined function names for labels encompasses the function definitions themselves as well as the body.

What does this mean? It means that any function defined in the labels function bindings may be used by any other function defined within the same labels form. Going through our example, in a flet the line (print-two nil) in print-one would have to refer to a function defined elsewhere, but in a labels it could mean another function defined inside the labels as we did here.

This means that while trying to make the who-calls references in labels we have to keep track of all of the function names defined in the labels while parsing through it. A little weird right?

So we tell our parser that whenever you see a labels, the first part of the tree (everything directly under List) will be bindings, and everything after will be the body, seems simple! Sadly, this is wrong! Remember, any function in the labels List can call any other function. So instead we have

to say:

Go through the List in labels. For each function parse the sub-tree with the extra knowledge of all of the other functions in the List.
Then the first part of the tree (everything directly under List) will be bindings, and everything after will be the body.

This is not exactly true either: maybe we have another flet or labels inside of the labels body rebinding the function. While possible, I want to ignore this complication for know.

So go through the list and try to parse print-one. We know it is from a labels List so it is a locally defined function. Its first element is its argument (what it binds) and the rest is the body. We see the print-two call inside of print-one’s body and we know it is a reference to the label defined print-two function because of rule 1. A similar argument holds for print-two.

We then reach the body of labels, see (print-one t) and (print-two t) and know that it is calling the labels defined-functions because of rule 2.

Now we know how to parse a labels form! Hope this was illuminating, and have fun parsing!

I would like to thank Ron Gut for making edits to this blog.

And here’s a new picture of Lyra and Wenwen:

Dull problem interesting problem.

December 22, 2018December 22, 2018 ~ jgodbou ~ Leave a comment

At work, there are two kinds of problems: there are the kind of problems you work on because you have to, and the kind of problems you work on because they are fun. As with any (good) job, you will always have a mix of these two problems. I doubt even Sundar (CEO of Google) wakes up and says “Ah, congressional hearing, lets do that.” But starting new initiatives, that’s probably an enjoyable day.

On QPX I definitely have both kind of problems, there are problems I stay awake at night trying to understand and solve or improve, and there are the problems that I begrudgingly do because, well, its my job. So lets discuss these two creatures.

As an example of problems nobody enjoys, code changes that have no effect on your service. I am the supporter of a service at Google that parses data, lets call it Parser (even though for a silly reason it’s actually called Splitter…). I have it set up on automatic releases with a batter of tests so if anyone changes the code, all one must do is wait a week for it to pass through the release pipeline. For the most part, this means supporting the service is a no muss no fuss kind of deal. Every once in a while though, I must actually do some work on it…

This week, that meant changing from library A to library B for some crucial but small part of the code. As I didn’t implement library A and don’t use library B that means I have to go grokking the API and understand whats going on. I will not use either library in the future so it’s not a learning experience that will bear fruit in the future, and it’s not an interesting change so I don’t have a great desire to do it.

Now for the opposite. As a 20% project me and a few of my coworkers maintain and update a Common Lisp indexing service, lets call it Indexer. Due to some intricacies of Lisps macro-system, we first have to compile the Lisp, and then due lexical analysis. As an example:

(defun print-some-ints (i)                                                                                                          
  (let ((mi (- i 1))                                                                                                                
        (pi (+ i 1)))                                                                                                               
    (print i)                                                                                                                       
    (print mi)                                                                                                                      
    (print pi)))

Compiling this code lisp will happily tell you about the function print-some-ints and it’s input i but it will not tell you about the locally bound mi and pi. That’s where we come in. (The let example was work previously done by Eric Wilson)

We already have this as an abstract syntax tree, and we run our lexical analysis over this syntax tree. We create a parser that says:

let bindings:

((mi (- i 1))                                                                                                                
 (pi (+ i 1)))

let body:

(print i)                                                                                                                       
(print mi)                                                                                                                      
(print pi)

We then go over the bindings so we know mi is bound on line 2 column 10 to 12 and pi was bound on line 3 column 10 to 12. When we are lexically parsing the let body and see the variable mi and pi, we create a cross reference to the binding in the let bindings. When people are searching through the code, no matter the system, and try to search for reference to mi we know right where to send them!

Note: Slime does a lot of this, please don’t send me those comments. Our determination of local bindings is slightly more powerful though, and we emit it as a service so it can be used more generally. This will hopefully be released some day as a kythe plugin.

For more advanced bindings like labels and let* this gets more complicated, and then there are macros! This kind of problem takes understanding of a language, creating lexical parsers, and writing tree algorithms, all quite fun. It’s a problem I keep thinking about at night and on the weekends.

The key is, do both. Always break up the monotony with an interesting problem.

Here’s a picture of Lyra in a baby Qipao.

Super-Primes

December 8, 2018December 9, 2018 ~ jgodbou ~ 1 Comment

Let’s do some programming!

Today, we will do some SBCL Programming on a Pixelbook using the linux Beta. I original was going to use this problem as an interview question, but I found another I liked better and I wanted to do a programming blog post. I will be using SBCL, as it is my usual language of choice now-a-days. I will also be using Emacs. The install of Emacs and SBCL worked normally with apt-get and the installation of Slime worked with the use of Melpa.

First, lets state the problem (From Don Hadwin, Eric Nordgren, Heydar Radjavi and Peter Rosenthal):

A Prime number is a Natural number greater then 1 that is only divisible by one and itself. A Super-Prime number is a prime number who is either a prime number from 1-9 or the sum of its digits is Super Prime. So:

2,3,5,7 are super primes
11 is prime and 1+1=2 so it is super prime
2999 is prime; 2+9+9+9 = 29 which is prime; 2+9 = 11 which is super prime; so 29 is super prime, and 2999 is super prime
13 is prime but 1+3=4=2*2 so it is not super prime

I don’t much care about finding primes. Here’s a shitty prime test:

(defun prime-p (n)
  (when (< n 2)
    (return-from prime-p nil))
  (loop for i from 2 to (sqrt n)
     when (= (mod n i) 0)
     do
       (return-from prime-p nil))
  t)

Really you should use a sieve, I’d probably give it as an oracle function.

Next we must be able to sum digits:

(defun sum-digits (n)
  (loop for cur = n then (floor cur 10)
       while (not (= cur 0))
     sum (mod cur 10)))

This uses the lisp loop sum function.

So how do we detect super primes?

(defun super-prime-p (n)
  (and (prime-p n)
       (or (< n 10)
           (super-prime-p (sum-digits n)))))

Okay, lets make this a bit more complicated, let the length of a super prime be the number of times we add up the digits. Then

2,3,5,7 have length 1
11 has length 2 since 1+1 = 2 so we summed the digits once

This gives a nice recursive structure. Now, can you tell me the first super prime of length i?

For this we must go through all the integers until we find one of length i. We will change our super-prime-p function to return length:

(defun super-prime-p (n &optional i)
  (let ((i (if i i 1)))
    (and (prime-p n)
         (if (< n 10)
             i
             (super-prime-p (sum-digits n)
                            (+ i 1))))))

and then we just iterate:

(defun super-prime-length (n)
  (cond
    ((= n 0) nil)
    ((= n 1) 2)
    (t (loop for i from 11
          when (eq (super-prime-p i) n)
          do
            (return-from super-prime-length i)))))

But this is wasteful, we don’t need super prime to go all the way down, and have to call that terrible prime-p function.

(defun super-prime-length-m (n)
  (cond
    ;; Just return for 0 and 1                                                                                                      
    ((= n 0) nil)
    ((= n 1) 2)
    ;; keep track of lengths found                                                                                                  
    (t (let ((map (make-hash-table)))
         (setf (gethash 2 map) 1)
         (setf (gethash 3 map) 1)
         (setf (gethash 5 map) 1)
         (setf (gethash 7 map) 1)
         (loop for i from 11
            ;; must be prime                                                                                                        
            when (prime-p i)
            do
              (let ((length (gethash
                             (sum-digits i) map)))
                ;; if your prime and your digit sum                                                                                 
                ;; is has a length you are super prime                                                                              
                (when length
                  ;; Either return or memoize                                                                                       
                  (if (= (+ 1 length) n)
                      (return-from super-prime-length-m i)
                      (setf (gethash i map) (+ 1 length))))))))))

The majority of this is setting up the hash. The rest we record what we have so far and continue. We can get some quick wins by declaring the types to be fixnum and compiling. If we were serious about our experiment, and wanted to find the longest length super prime known we would get a list of all known primes and iterate through that, removing the need of the prime-p function.

As far as I’ve heard it’s not known whether a super prime of arbitrary length exists. Using either of these we find 2999 of length 4 quickly. These are also different from the super primes you find when doing the usual google search, so I apologies for bad naming.

I hope you enjoyed this walk down lisp lane. Lyra and I are tired!

Dragonfly

December 1, 2018 ~ jgodbou ~ Leave a comment

In case you haven’t heard, for the last few months there’s been talks about Project Dragonfly at Google [1]. This is a project to have a Google (branded?) search engine in China. There has been leaked documents [2], leaked meetings [3], people have publicly quit and open letter have been writ. I’ve talked to many of my friends, and lo and behold I have opinions.

Notes: I have no knowledge except for the leaked documents, so don’t look for anything besides that. I’m also talking for myself, these are my thoughts, and only my own.

Why would I write this? A few days ago I was talking to a friend about pro’s and con’s of Google in China, or really western companies working in China. I think I have opinions to add, and I hope they will be taken seriously. Really, this could easily be an argument for Bing to start a search engine in China…

First, a (decent sized) Google presents in China would give the west some soft power that it is quickly losing. The most recognized brand in the world is Coca-Cola followed by McDonald’s. [5] This is a way the west has been able to spread ideals throughout the world, capitalism at it’s finest. One of the big things for my wife to do with me was to go to Starbucks. It was something she had seen in movies and tv shows, and it grew into a more romantic idea. Spreading western countries gives us power, it gives a view of the west to the rest of the world.

Second, China already has competitors that dominate the marketplace: Baidu, Alibaba, Youku, WeChat, etc. If you have Chinese friends from the mainland, and you look at the portion of the internet they browse, it may look very different then what you expect. This second internet is slowly expanding to the rest of the world, but it’s keeping its censorship.

Third, Google acts in country according to the laws in EVERY country it operates in, so do all of the major companies, except for some well known companies that are getting sued… Apple had to partner with data companies in China in order to have it’s cloud, and it’s walled garden of a software store is restricted based on the Chinese authorities views, at least with android you can side-load [6]. There’s been many countries that have censored the internet, and Google has complied [7].

Fourth, if your in the country you can push laws in your favor, you can read them how you want to, and do good things. If your not there, then you have no voice.

All of this said, there is a line where the price is to high to enter, but there is also a heavy cost of not entering. I don’t know where we stand, I just hope we keep an open mind.

Last thought:

We (netizens) had a dream of a free and open internet, where ideas flourish and free speech reigned. I still have this dream.

Trolls have entered the fray, and made much of the internet an abhorrent place. We have seen governments topple, and regions get destabilized. A lot of people have been killed because hate speech has seeped into the net. I watch the news everyday, I’m more aware of the pro’s and con’s of a free internet. The internet has been used as a force for both evil and good. I don’t know what path we’re headed down.

I will continue to support the free internet. I was once told don’t put on the internet anything you would not like to have your name tied to. I think its more don’t put on the internet something you wouldn’t want your daughter to see.

Thank you,

Jon

PS: My mind is always open to opposing viewpoints. If your on this blog you know my email address.

Links:

[1] https://en.wikipedia.org/wiki/Dragonfly_(search_engine)

[2] https://theintercept.com/2018/11/29/google-china-censored-search/

[3] https://theintercept.com/2018/10/09/google-china-censored-search-engine/

[4] https://mashable.com/article/former-google-employee-dragonfly/#5q8Il3Kt1gqE

[5] https://www.readyartwork.com/10-most-iconic-logos-all-time/

[6] https://www.theverge.com/2018/7/18/17587304/apple-icloud-china-user-data-state-run-telecom-privacy-security

[7] https://en.wikipedia.org/wiki/Censorship_by_Google

NYT Chinese Internet Article

Back to Work

November 25, 2018 ~ jgodbou ~ Leave a comment

First: I know this is supposedly a programming blog, and that’s gone a bit off the rails. I hope to do a bit of programming in a bit, I’m working on some stuff at work that I hope will get broader reach, but having a little one changes your prerogatives quite a bit, so here we are.

img_20181118_150242 — Where’s daddy going?

After six weeks off from work I’m back at work! Well it’s a Sunday so I’m at home, and its a long weekend so it wasn’t a large return to work but it was a start.

The day, there wasn’t much coding to do. I was able to submit that change list I had so many weeks ago. Due to change in the repo, the easiest way was to make a new cl and submit that, silly right. Currently I use mercurial, and I never have a good time trying to update changelists, it always goes bad. I had a meeting to talk with my manager, and went home to help with the baby, and look at the pending work I could do.

img_20181123_143616 — Taking care of Lyra, she sleeps alot

The next day I grabbed a minor bug to ramp back up. After doing some work, I had to go back home while my wife went to the doctors. Here’s a really big thing to note: As a software engineer, we are given flexibility to work from wherever we need to. This is invaluable having a kid, you can work from home, work later and watch the kid while your spouse is away. Use this luxury, and be thankful for it, but get your work done.

img_20181121_120039 — An awesome barista, and look at those cups!

Finally, Wednesday I spent my first full day in the office. I was able to get another cl done (though not finishing the bug). I was also able to start looking at my pet project, a happy lisp indexer. My wife spent her first full day alone with Lyra.

img_20181118_1343051 — Wenwen trying to get work done.

Takeaway: Be grateful for the work flexibility. It’s been beneficial both when I had to go to Hong Kong when my wife was stuck in China, and now it’s amazing with the baby. Make sure when you choose where to work, they’ll let you be where you need to be.

Traveling With Lyra

November 16, 2018 ~ jgodbou ~ Leave a comment

It’s that time of the year, the time when all graduating mathematicians must go out into the world and find real jobs. Okay, this time has almost passed, most postings are hitting there deadlines but with having a baby my wife is starting now. Couple that with having to research my wife has been traveling back and forth to meet with her adviser quite a bit lately.

What does this mean? Driving the 1.5 hours up to the University of New Hampshire. That’s a fairly short drive, but having a baby adds an instant difficulty multiplier to the problem. The first time we did it we were okay, we packed most of her stuff, our laptops, and some math into the car and headed up. Things we needed (for her) amounted to:

Car seat
Stroller car seat fits into
Portable bassinet like thing
Baby clothes, with at least 2 changes.
Diapers (a lot of them, babies like to poop).
Plastic mat to change her on.
Wipes
Several blankets, it’s cold in New England
Vitamin D

It’s much worse if you bottle feed, at the moment it’s all breastfeed so that lightens the stuff.

img_20181012_172422 — It folds up, if you have a degree in engineering, us math folks are helpless…

As I said, the first trip was okay, she slept for most of the ride (after a while babies tend to sleep in car seats). We stayed at our advisers, and one of us took care of the little one while the other did math.

img_20181110_163032 — Math that is only questionably useful.

The second trip was a different story…

unnamed — Truly https://mathwithbaddrawings.com/ is much better at this.

First, we forgot the portable bassinet, so the biggest problem was where would she sleep. We made one out of blankets so it worked out, that’s why you bring SEVERAL blankets. Also, thanks Mehmet for the awesome fox blanket. 🙂 Also, we commandeered Mehmet’s UNH office for two days and which made our lives a bit easier.

Next even if you don’t think you need all the items listed above (and more) you are DEAD WRONG. We were driving to UNH from our advisers house and the little Lyra started to cry. We parked the car, and Wenwen asked me “Does something smell bad?” She had a poop, a big poop, her biggest poop. Her clothes were all dirty, we were stuck in a parking lot, and we had no extra clothes (remember they were at our advisers house).

What did we do? We changes her, there, in the cold, as fast as we could. We put aside the poopy clothes and wrapped her in the blankets we had. She was ANGRY. Wha-ed all the way to our friends house. Thankfully, they had extra clothes from when their child was that age. All I can say is yes, you will need all of the stuff, expressly when you don’t bring it.

We made it home, and the little one is happy. Just remember, bringing a baby is a lot harder then just yourself, good luck.

experimentalprogramming

Programming and life