DEV Community: angelamchunu

What they don’t tell you in the “Starting a new position” posts.

angelamchunu — Mon, 12 Jun 2023 20:15:58 +0000

Everyday on LinkedIn we see someone starting a new job. There is always some beautiful story about how excited they are to start their new journey. We only see the end result, the success story and sometimes a perfectly inspirational summary of how they got there. I wish I could add to the list but I think I owe my past self a good venting . There are plenty of resources that can help you get motivated , this is not one of them. This is the dose of wallowing you need , just to say you are not the only miserable one and there is definitely someone out there hating it as much as you are.

My biggest unsolved mystery is how people job hop so often, I hated so much about it. It’s time consuming, it’s emotionally draining and it’s just overall exhausting. What makes job hunting such an extreme sport is that all your efforts don’t always yield results. You can put in your absolute best and still have nothing to show for it. From recruiters ghosting you, to falling off the final stage of a 5 step interview process, 10/10 would not recommend. Unfortunately, in order to progress in your career, it has to be done. There are a few things that make job hunting a different kind of hell, here are some of mine.

Recruiters

Where do I even start , I can’t summarise recruiters in a paragraph. Between not responding at all ,to trying too hard to convince you take a role that doesn’t benefit you, we could be here all day. I have met a hand full of recruiters that I felt have been on my side. It feels like they are more concerned about “making the sale” than finding a good fit. How are you reaching out to me about an Android project when I don’t have a single mobile dev technology on my profile? I wanted a greenfield project but I mean if they’re looking for someone to maintain their legacy system that sounds like a great match.

Its almost as if getting to know you or what you want is a big ask. I once received the following message on LinkedIn :

There’s so much to unpack here. The only information I have is the company name . Not the technologies they’re using , the domain or even the skills I’d need . I don’t have enough information to know if I want to know more. I can get past all of that but, really my biggest concern is who on earth is Martha? My name is literally right there while you’re typing the message. How can I trust you with my next career move if you can’t even get my name right?

Assessments

Just kill me now . Was chewing glass not an option?

That might have been an over-reaction, but in my defence, I really hate them. I’d prefer a technical panel interview any day over an assessment. While I can appreciate that the company needs a way to filter for and find the best candidates, it might be filtering them out. It’s okay to go back to the drawing board sometimes .

There’s usually two types of assessments, the first one is a take home assessments which ranges anything from odd occurrence to building a full end to end project with responsive screens, 100% unit test, mutation test ,acceptance test coverage, cure for world hunger and a fix for the country’s electricity crisis. It’s an entire feature that needs to be done in 2 days all while still having to do your actual job. I’ve had some of these that aren’t that bad, some companies can be reasonable. But then there’s the monsters that give you an 8 story point ticket and then not reply after you submit. Surely that’s the makings of anyone’s villain origin story .

The other type of assessments are a time machine to your varsity days with exam like rules. It’s a timed closed book assessment, no help from the internet or friends. My main issue with this is that it gives the idea that to be the best developer, all the answers must live inside of you at that specific moment in time . When really that’s not accurate at all. The answers are on StackOverflow/Udemy/YouTube, they’re with your team mates , they’re in a conversation with an experienced architect in the company . Development isn’t an all or nothing in that one moment. It’s people working together over years to continuously do what’s best for the problem. Someone you’ve never met is one day going to have to change your code because it’s no longer the best fit. All of that to say, exam like assessments are far from what you’re actually going to be doing day to day . If you’re really about a team focussed company, dare I say agile, why are we simulating a stressful scenario that will never actually happened on the job . Production issues are less stressful than these assessments, that’s a lie but you get the point.

Bad Interviews

A part of me wants to skip this section because I’ve had so many embarrassing moments that I’d really rather forget, but surely we all have ?Are you even job hunting if you don’t have bad interview stories that you look back and cringe at ? The ones where you struggled to answer a good 60% of the questions. I’ve had some really bad ones before. Bad doesn’t mean I just didn’t get it , bad means I was racking my brain trying to remember the word “request”. Bad means I couldn’t answer what language the computer “speaks”. I blacked out on the word binary… BINARY! I once had an interview go so horribly, the interviewer implied that someone did the assessment for me. He couldn’t possibly reconcile the person they were interviewing to the the code that had been submitted. Now while this very rude, I could understand the disconnect, it was really bad .

It’s very important to take these kinds of experiences with a pinch of salt . They’re not at all an indication of your actual skills . They’re just off days, we all have them and you’re allowed to have them . They’ll just tell a funny story one day. More than anything, they teach you what not to do .

I wouldn’t be doing this list justice if I didn’t mention LinkedIn and how painful it can be there. Don’t get me wrong it’s a good place to find a job , or at least get you in touch with the right people . But, seeing “so and so started a new position” everyday after reading “we regret to inform you” is a special kind of hell. Especially if you follow the company and they’re congratulating everyone. Sometimes this can serve as motivation but on bad days, it’s torture . You need to find a healthy balance for it or it can really leave you feeling defeated. This might sound like you are a hater that can’t celebrate other people’s accomplishments but I think you can be simultaneously happy for people and sad for yourself at the same time. You can still be happy that they’re thriving but still be sad that you’re still in the same place.

Almost but Not Quite

For every successful interview, there’s probably a few “We regret to inform you” emails . These interview experiences are probably the most deflating of them all . It’s the ones you’re most excited about because it feels like this might actually be the one. You did everything “right”, you put in hours on Leetcode/HackerRank, you’ve checked with Glassdoor and you’ve done a couple of practice interviews , you even did your affirmations that morning. You’re so deep in interview prep even your YouTube algorithm is stuck on a “Why should we hire you best answer ” loop . The interviews went great; you loved meeting the team, you probably even had a few rounds , they’ve told you everything about the company and sounds just like what you want. I think you get the picture ,you put in the work and if you’re anything like me, you’re cautiously optimistic, without the caution.

You can tell within the first 5 seconds of the conversation/ email if it’s gonna be a rejection. There’s a tone or certain amount of waffling that happens, almost like filler sentences before they break the news. They sort of recap the process to tell you how well you’ve done only to tell you to kick rocks. I think it’s worse over the phone because you still have to listen to the whole speech and respond with a tone that doesn’t make it awkward for everyone involved. It’s basically the professional version of “it’s not you , it’s me” . I can appreciate that this is probably uncomfortable for the recruiter too, but they can write their own article. Surely they could just send an email saying “Nah sis, this ain’t it” . Obviously I’m joking… Maybe.

Aside from having to tell your family and friends after all the excitement you had that you got rejected and listen to all the cliches about rejections being redirections . The worst part is having to pick yourself up again , it’s having to somehow find it in yourself to put yourself through all of that again. It’s easier after a bad interview, or helpful feedback because you know what to tackle. But I can’t tackle “The team really loved you, but they’re looking for someone with a bit more experience, please try again in a year or so” . How do I tackle that ? How do I make sure I don’t repeat that same mistake? It’s vague and unhelpful, I could literally just repeat the same year and try again and still fail. I had been very specific about the companies I wanted to apply to and at this point it felt like I was aiming way too high. Somehow with all that doubt, you have to try again with a clear positive mind . It’s the absolute pits.

Now that I’m done venting, all of these are just a bump in the road. As lame as it sounds, your friends are right about rejection being redirection. Each of them are lessons that will hopefully get you closer to where you want to go. Being kind to yourself throughout this process can go a long way, hard as it is, you shouldn’t take the rejections personally. There is a light at the end of this painful tunnel, I promise. Good Luck :)

Beginners guide to optimization in C# (Part One)

angelamchunu — Mon, 04 Nov 2019 14:10:39 +0000

When you’re working on a legacy system, after some time there are bound to be a few issues. It’s an occupational hazard; you have different developers rotated on and off the project, different approaches and different priorities. Depending on the task, efficiency of a solution is usually an afterthought and over time this can cause some slow running queries.

Tackling slow running queries can be overwhelming, where do you even start? Is it your database, is it your code, is it the network, is it a ghost in the machine. You’ve looked at your profiler and it tells you which method is the time waster but what now? In this two part series I aim to show how changing little things can make quite a difference.

Part One of my optimization post focuses on the code side of things ; how to get the best out of LINQ by choosing the “right” data structure , deferred execution and your loading strategy.

Data Structures

Data structures are a way of storing data in an organised manner. Each structure is aimed at being efficient in a particular function, mainly sorting, searching and insertions/deletions. Therefore choosing the right one can save a substantial amount of time. Data structures are important when using LINQ, most beginners default to IEnumerable or Lists which gets the job done but isn’t necessarily optimal. Here are some examples of data structures and how to use each one for the best performance.

IEnumerable

IEnumerable is an interface that is implemented in most C# collections. They are best used when writing multiple and embedded LINQ queries.
They tend not to fair well with aggregate function such as count , max or average. This is because we don’t have any knowledge of the number of objects in the collection. A common mistake is using the Count() method which iterates through the entire collection to count each item, needless to say, this is where optimization goes to die.
IEnumerables also aren’t great when it comes to finding a particular value in the collection , it has to iterate through every item until it finds the value which sucks if the value is the last one.

Lists

Lists are one of the most common data structures, they are a collection of items. They implement IEnumerable interface, they have knowledge of the size of the collection and have indexes. Indexes are keys for finding a specific location, Lists use indexes to find values at a particular position in the collection. For instance if you need the 100th item in the list, it will go to the item directly and retrieve it, unlike having to search 99 items before finding it. This also makes insertions and deletions much easier by providing the index of the item.

Lists also have their downfalls, they are unable to search for a particular value without the index. So for example if you have a grocery list with Milk, Eggs, Wine and Broccoli and you wanted to find out if you remembered to add Wine on the grocery list. Using a list would not be ideal because it would iterate all items, meaning it would compare “Wine ”with “Milk ”and then “Wine” with “Eggs ”first before reaching “Wine”. This isn’t the worst thing if you only have 4 items, but what happens when you own a chain of restaurants? The list will obviously be more than 4 items , it’s most likely going to be extremely long. Will you iterate the entire list to find one item? In C# a common beginners mistake is using the Contains() method which does exactly that, when you have large amounts of data this can get slow.

Dictionary

Dictionaries are optimized for searching a particular item in a collection using key/value pairs. This works by choosing a key which acts as your index . The key is used in a hash function to create a hash value and store the data at that hash value. They are very similar to real life dictionaries , if you are searching for the definition of a word , you would check the index page for the word you are looking for and it gives you the location of the definition. Without the index, you would have to look through all the words in the dictionary until you find the word. Therefore on lookup , the key is used to find the particular value , giving a O(1) lookup no matter how large the data gets compared to lists which have O(n) .

For example, if we have a list of subjects and we want to check if “Theology” exists in this list. As opposed to using the Contains() method in a List, converting the List to a Dictionary and then searching for it as illustrated below.

Dictionary<string,int> subjectsDictionary = 
subjectsList.ToDictionary(key => key.SubjectName, value => value.SubjectID);
subjectsDictionary.ContainsKey(“Theology”);

This also should be used with caution, there is a cost to serializing a List to a Dictionary. The value of converting is seen when you have multiple lookups.

HashSet

Hash Set is an implementation of a Set that uses hash functions as its searching optimisation algorithm. Sets are the same as the mathematical definition which is a collection of distinct objects. Meaning it is a collection of objects that ensure there is no duplication. HashSets work very similar to dictionaries because they use a hash function on lookup but differ in that they don’t use key/value pairs, they only store that actual value. They are also optimal in finding a particular value.

Deferred Execution

The idea of deferred execution is that you only enumerate once the query is filtered to the detail you need it to be. i.e serializing an IEnumerable to a List (calling ToList) too soon can add extra time to your query. In calling ToList method, you are bringing the entire list into memory . If the list is not filtered accurately , unnecessary data will be enumerated. Basically, wait to the last possible moment before you enumerate your results .

Say for example we have two classes, Students and Subjects. We want to use Linq to find the names of students over 25 that are studying Psychology. One possible way of doing it is the example below:

var psycStudents = students.Where(s => s.SubjectID == 1).ToList();
var psycStudentsOverTwentyFive = psycStudents.Where(s => s.Age > 25).Select(s =>s.StudentName);

The above code would work, but the problem is that it enumerates before properly filtering. It brings all students that are studying Psychology(SubjectId =1) into memory which is unnecessary because we are only looking for a subset of these students. A better way of writing this query would be :

var psycStudentsOverTwenty = students.Where(s => s.SubjectID == 1 && s.Age > 25).Select(s => s.StudentName);

This way Linq only returns the data we need and saves time especially if the dataset is large. This can also help when you need to iterate through the items, it ensure that only the items you need are iterated over.

Loading Strategy

Entity Framework(EF) has 3 ways in which it handles the loading of data: lazy, eager and explicit loading . In this section I will briefly discuss what each strategy means and how to use each one to help optimise your code. The loading strategies are changed at the DbContext (intermediary class between your database and domain classes) level, for the examples let’s call the context VarsityContextEntities.

Lazy Loading

This is the most common of the three, the name gives some context into how it loads data. If you are a lazy person , you will do the bare minimum , the same applies with data retrieval . When making a query, only the requested entity is returned and nothing more. EF retrieves data as it is required in the code, so there is not need to load all entities upfront. Lazy loading becomes helpful in one-to-many relationships where one entity is linked to a list of another type of entity. Similar to the Student and Subjects example, each student can have many subjects. If we had to query for all the students, enabling lazy loading would ensure we would only get the Student entity and not Subjects which can save some time. An example in code would be as follows:

var students = context.Students.ToList<Student>()

The issue with lazy loading is that it leads to the N+1 query problem which is when a query is made for the parent entity (Student), there will be one made for each child entity(Subjects) . So instead of making one call to retrieve all entities, N+1 queries are made(N for retrieving the Subjects for each Student and 1 for the initial call for Student) . This causes multiple calls being made to the DB which isn't great for performance.

Eager Loading

When making a query to the database, the requested entity along with all its related entries are returned. For example, if the Student entity was linked to Subjects and Faculty. If eager loading is enabled , when a query for students is made, both Subjects and Faculty entities are retrieved. This becomes useful if both entities are needed, it reduces the number of calls made to the database. A way of implementing eager loading is using the Include() method , here’s an example of Student being loaded with their respective Subjects and Faculty using eager loading :

using (var context = new VarsityContextEntities())
{
    var students = context.Students.Include("Subject.Faculty")
                    .FirstOrDefault<Student>();
}

Eager loading is also a solution for the N+1 problem because all the entities you need are already loaded in just 1 query.

Explicit Loading

Explicit loading is similar to lazy loading in that it only returns the requested data, but you can explicitly request a particular entity. You tell EF when to load which entity . For example, if we want the students but somewhere later in the scope we would like to use the Subject entity. Instead of making two calls to the database, the first for retrieving Student and the second call to retrieve Subjects, you only make one call. Explicit loading is achieved by using the Load() method, using the above example, this is how it can be shown in code:

using (var context = new VarsityContextEntities())
{
    var students = context.Students.FirstOrDefault<Student>();
    context.Entry(student).Collection(s => s.Subject).Load(); 
}

As a beginner, C# provides you with quite a few optimisation traps. You just press dot (.) and you are instantly bombarded with a list of options to choose from. It is very easy to just pick the one that sounds closest to what you want without being cognisant of the ramifications. Hopefully this post makes you a bit more aware and intentional in your coding.

The real reason your “diversity hire” leaves

angelamchunu — Fri, 05 Jul 2019 14:27:10 +0000

Contrary to the title above, there are many reasons why people in general leave a company; pay, distance from home, insert generic sugar coated reason for leaving. But in my experience, diversity hires leave because companies don’t truly believe in diversity as they promised in the interview.

A company will claim to care about diversity but all the games in break room are enjoyed primarily by men. All executives are men, most events are designed for the men, all executives mingle with the men. This creates a culture that is clearly designed for men, and leaves little room for women to fit in anywhere. I don’t mean that there’s some form of testosterone entry fee, I just mean the culture is brogrammer compliant. There is no active effort to include anyone that is not a quintessential developer.

Many companies show very little desire to deviate from the norm — if it ain’t broke don’t fix it. They’ve yet to experience the true effects of a diverse team.

I’m gonna use Hollywood to explain what I mean. Let’s take Brooklyn nine-nine as an example, they are truly a diverse cast. Every character has an equally important role, their roles are independent of their race or gender. If Rosa or Captain Holt left, you would notice, it wouldn’t be the same without anyone of them. They could make an episode with just the 2 of them and it would still be funny. Their differences truly add to the humor of the show and in turn make it great.

In contrast, if you take a movie like The Other Woman, Nicki Minaj, whom I love, had absolutely no impact on the movie whatsoever. You could take out all her scenes and the movie would make sense. She was clearly there for some quota I’m assuming Hollywood is starting to impose. Many companies that say they care about diversity end up being exactly like this.

In the tech world, the Nicki equivalent would be the one who always has to do the documentation, gets a report using a script already written for them. They’re always given the same type of mundane tasks while their peers are pushed or mentored. They are left out of design meetings, technology upgrade decisions are made without their input and just overall subtle exclusion.

A diversity hire dreams of finding a Brooklyn nine-nine job but constantly find themselves in a ‘The Other Woman’ situation. Basically what happens is your diversity hire realizes they deserve better than just being the sassy black friend with great advice and funny one liner jokes. They will leave because they are too qualified to not be taken seriously. They will leave to pursue a challenge that is currently a luxury for their peers. They will leave because brogrammers are gross and no one wants to see that.

Until companies truly understand the benefits or need for diversity, not just a BEE Score need, then they will most likely always hemorrhage diversity hires.

Consuming a SOAP web service in Jython.

angelamchunu — Wed, 26 Jun 2019 11:43:02 +0000

A few months ago I was placed on a project that required an automated process to communicate with an API . The automation was done in Jython, an implementation of Python on the JVM which allows for dynamic compilation of java objects. Basically if you want to use a scripting language packed with a library of tools, you should consider Jython.

I went through a few approaches before I landed on this one, my first approach was to consume it using Python libraries but the firewall prevented any pip installs. You could try manually install all the dependencies, but why not watch paint dry instead. There is a way around the firewall but it only works if you have the proxy, which I didn’t so I had to find another way.

The second approach I tried is to consume it directly in java and package it into a jar file and call it in the jython application. This will work but I wouldn’t recommend it because you are managing two separate applications. If something breaks, how do you know where your problem is? Is it Jython or Java? You will have to get the original source code, change it, repackage it and retest. This approach is not easily maintainable, especially if the you leave. All the new developer has is the jar file and debugging becomes painful.

There’s an easier way to solve this. Jython already allows for Java libraries. Using a Java library with Jython syntax is a much easier way to do this.I decided to go with the SAAJ API and this is how I did it.

I created a service that returns Beyonce album release dates given the album name(Yes I’m a huge fan).

The first step is to construct the SOAP message that you’re sending. I did it a little different from the documentation. I added the soap envelope to an xml file, I substituted the parameter (i.e. the album name) with a variable that will be mapped in the code.

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tem="http://tempuri.org/">
<soapenv:Header/>
<soapenv:Body>
<tem:GetBeyonceAlbumYear>
<!--Optional:-->
<tem:albumName>${albumName}</tem:albumName></tem:GetBeyonceAlbumYear>
</soapenv:Body>
</soapenv:Envelope>

The mapping of the variables is relatively easy, using the StrSubstitutor method from the apache commons library. Have a look at the code below which maps the variable :

def mapVariableToRequestFile(albumName):
  mapping = HashMap()
  mapping.put("albumName",albumName)
  xmlFile = File(pathToXmlRequest)
  fileStream = FileInputStream(xmlFile)
  template = IOUtils.toString(fileStream,"UTF-8")
  sub = StrSubstitutor(mapping)
  request = sub.replace(template)
  return request

The next step is to create the actual message that will be sent. The library creates the message from the bytes of the request, we can easily get the bytes from our request returned from mapVariableToRequestFile. Explicit casting is sometimes required, the type that Jython returns might not necessarily be the one you need. In order to use the getBytes() method of the String class, I had to cast request to a String because it was returning a unicode object.

def createSOAPMessage(request):
  messageFactory = MessageFactory.newInstance()
  stream = ByteArrayInputStream(String(request).getBytes())
  soapMessage = messageFactory.createMessage(None,stream)
  soapMessage.saveChanges()
  return soapMessage

The final step is to send the actual message. I did not use any authentication in my example(no cert required) and therefore used the library’s connection method.

def sendSoapRequest():
  request = mapVariableToRequestFile("Lemonade")
  soapMessage = createSOAPMessage(request)
  soapConnectionFactory = SOAPConnectionFactory.newInstance()
  soapConnection = soapConnectionFactory.createConnection()
  soapResponse = soapConnection.call(soapMessage,soapEndpointUrl)

You can easily see the response by writing to system.out and printing it out as follows.

soapResponse.writeTo(System.out)
System.out.println()

This method , unlike doing it in java, doesn’t force you to do any error handling. You can add that in yourself like a good developer, the exception types will also have to be imported and handled accordingly.

Finding a solution for my problem was a whole nightmare for me, here’s to hoping it eliminates that for someone else.