• 开源镜像
  • 开源沙龙
  • 媛宝
  • 猿帅
  • 注册
  • 登录
  • 息壤开源生活方式平台
  • 加入我们

开源日报

  • 2018年11月4日:开源日报第241期

    4 11 月, 2018

    每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文,欢迎关注开源日报。交流QQ群:202790710;微博:https://weibo.com/openingsource;电报群 https://t.me/OpeningSourceOrg


    今日推荐开源项目:《微信小程序资源大全 MasterWechatApp》传送门:GitHub链接

    推荐理由:推荐给微信小程序开发者的资源合集,包括官方文档,各种各样的工具,资源和教程,以及一些好用的轮子和示例 demo,这能在开发的时候帮助你少走不少弯路,要知道,自己造轮子是为了学习,但是实际上要用在产品中还是选择发展成熟的轮子更为合适。如果你有在别的地方看到合适的可以添加进来的资源也非常欢迎大家的贡献。


    今日推荐英文原文:《Ping Pong Pair Programming》作者:Anthony Sciamanna

    原文链接:https://medium.com/@asciamanna/ping-pong-pair-programming-cf994a9981a4

    推荐理由:乒乓配对编程,是一种两个人配对工作的形式,以测试一个单元为例,A 想办法输入一些数据让它不能正常工作,B 则要想办法修补它应对 A 的破坏,然后交换,循环往复直到他们两个已经拿这个单元没办法为止。作者在这篇文章中介绍了这种形式和好处,兴许以后你可以尝试用这个方法提高团队的工作效率。

    Ping Pong Pair Programming

    The most effective form of pair programming I’ve experienced is called Ping Pong Pair Programming. I find it so effective that I prefer not to pair at all if I cannot ping pong program. The majority of development teams I’ve encountered who occasionally pair program don’t practice ping pong pair programming. They view “pairing” as one developer taking a much more passive role. I suspect these teams would enjoy pair programming more and identify its benefits if they tried ping pong pairing.

    I’ve read about Ping Pong Pair Programming as far back as 2002. However, I didn’t begin to practice it until I joined an eXtreme Programming (XP) team. I quickly took to the practice, finding it incredibly engaging and enjoyable. As someone who values collaborating with other developers this was collaboration at a level I had not previously experienced. Furthermore, this constant and close collaboration built a camaraderie with a team of developers which I have not been able to replicate since. There are about eight to ten developers with whom I’ve worked that I feel an incredible bond with as a result of constant pair programming over a significant period of time. These are folks I would jump at the chance to work with again.

    Description

    Ping Pong Pair Programming is the intersection of two XP practices:

    • Test-Driven Development (TDD)
    • Pair Programming

    Ping pong pair programming is deceptively simple. Given two developers, Developer A and Developer B:

    • Developer A writes a failing test
    • Developer B makes the test pass writing only enough code to make it pass
    • Developer B now writes the next test
    • Developer A writes only enough code to make that test pass
    • Continue until Developer A and Developer B both agree that there are no more tests for the unit they are currently working on
    • Either developer can refactor the code only while all tests are passing

    Computer Setup

    One of the biggest struggles I see with development teams trying to pair program is that they don’t properly setup their development machines to accommodate this way of working. The optimal setup is a single computer with two input devices. That’s two monitors, two keyboards, and two mice. Frankly I won’t pair unless there are two input devices because I find it uncomfortable to work having to pass them back and forth between developers.

    Physical Environment

    Our pair programming workstation setup

    Another very important aspect of pair programming is how the pair of developers are seated in relation to one other. The worst way to sit while pair programming is one developer in front of the other sharing the same monitor. Both developers need to be comfortably seated and able to take control of the computer at any point in the pairing process without any additional effort. The most common seating arrangement is two developers seated next to each other. While I don’t find this to be the optimal seating arrangement, it is usually the easiest in work environments that weren’t designed with pair programming in mind. I do however find myself resorting to it more often than I’d like to.

    The ideal seating arrangement that I’ve found through experimenting with a previous team is sitting either directly or diagonally across from one another. This enables pairs to easily look at the screen and look directly at each other at all times during the pairing session (see the photo of one of our pairing workstations).

    Benefits

    Flow

    I consider the biggest benefit of Ping Pong Pair Programming is how quickly the pair achieves flow. Flow is an important concept in programming. It is the point at which the problem space is completely loaded into the head of the developer and they begin making the most efficient progress on the solution. Any interruption at this point sets the developer back.

    When practicing TDD and pair programming a much smaller problem space needs to be managed to begin making progress on a solution. This enables developers to get into flow quicker than other programming styles where the entire application’s problem space needs to be known. Working in this way, a distraction is much less damaging to the progress of the pair.

    Avoids Mismatched Pair Issues

    In a pair there is typically one developer who knows more than the other either about the domain, the problem currently being addressed, the technology stack, or even programming in general. This mismatch could lead to poor pair programming sessions with the more experienced programmer dominating the keyboard.

    These mismatches can cause developers to feel like they are providing very little input and they tend to get bored and disengaged from the work. While more experienced developers can feel like they are doing all of the heavy lifting. It is no surprise that these developers eventually decide pair programming is not for them.

    Ping Pong Pair Programming avoids these issues as each developer is taking turns writing tests and making them pass. If the developer is unclear about what test to write next or how to make a specific test pass this prompts a conversation.

    Learning & Mentoring

    Given that conversations are constantly happening in the pairing session this is a very natural way to incorporate mentoring into your team. This type of mentoring is more effective than mentoring sessions between developers and managers in private one-on-one meetings. Don’t get me wrong, you should be having one-on-one meetings with your manager, but the real mentoring should be happening while building the software. By pair programming, mentoring is something that is occurring constantly and naturally between developers of different skill levels. Additionally, learning new techniques, 3rd party libraries, tools, team practices, team coding conventions, etc. becomes very easy and built-in to the pairing process.

    Some teams will even stop performing code reviews and allow the review to happen during the pairing session. I believe this is entirely dependent on how often your team switches pairs. If one pair commits to a user story and only finishes pairing when the story is complete I think that code should be reviewed. As Bryan Helmkamp stated in his Baruco 2013 talk both developers in a pair are the authors, therefore they still require an editor. However, if many developers on the team have worked on the user story through regular pair rotation the code review becomes redundant.

    Teaching Test-Driven Development

    I am a huge advocate of TDD. I have had a lot of success with it and I have yet to find a situation in which I do not want to utilize it. Test-Driven development, while conceptually simple, takes a fair amount of time for developers to get truly comfortable with. There are some common struggles that developers new to TDD experience. These include:

    • Not doing the simplest thing to make a test pass
    • Taking too big of a step
    • Writing integration tests instead of unit tests

    Even the act of just writing the test first is something that is a challenge for developers who haven’t worked that way previously. All too often “unit tests” that inexperienced developers write are impossible to maintain, impossible to reason about, and end up being an opposing force instead of an enabling force in the organization. These are situations where teams give up on unit testing and decide “it didn’t work for us.” See one of my previous posts for more on this topic, xUnit is Not Unit Testing.

    Being introduced to TDD in a ping pong pair programming situation is the fastest way for a developer to get up to speed and comfortable with the practice.

    Pairing with a seasoned TDD practitioner, developers new to the practice will learn:

    • How to avoid external dependencies (database access, file system access, external services) that slow down unit tests.
    • The recommended scope and size of a unit test.
    • How to make unit tests as clear as possible so they can be an excellent documenting technique.
    • How to write testable code and begin to recognize the bad programming habits that they have accumulated over time that make unit testing their code impossible.

    The fact remains: Good design is testable, and design that isn’t testable is bad.
    — Michael C. Feathers, 
    Working Effectively with Legacy Code

    The Game

    As developers become better at Ping Pong Pair Programming it can begin to look like a game (hence the name Ping Pong Pair Programming). A developer will do the minimum to make a test pass including hardcoding an expected result if there isn’t a test to prevent them from doing so. If a developer writes a test to exercise a conditional statement but only one branch of the conditional statement is currently tested, the implementer will not add the conditional statement. Two tests would be required to test both branches of the condition and therefore shouldn’t be implemented until both tests exist.

    From the perspective of the uninitiated developer this can seem silly or wasteful. If you know how the code is supposed to look why wouldn’t you write it that way in the first place? But what looks like a game from the outside is a very important part of TDD and pair programming. It is doing the absolute minimum to make a test pass and no more without another failing test.

    Pair Rotation

    When I first started Ping Pong Pair Programming we switched pairs on the team twice per day (two four hour sessions). In the early days of XP teams tended to keep the same pairs throughout an iteration. Switching pairs regularly has several benefits over keeping pairs together for the duration of an iteration. It alleviates the need for code reviews (as mentioned previously) and it spreads knowledge throughout the team very quickly. In my experience, every developer on the team paired with one another, thus there were no “favored pairs.” Very rarely would a user story be completed in a single pairing session, this resulted in a true team-owned solution and team accountability for the success of every user story.

    Promiscuous Pairing

    Promiscuous Pairing recommends switching pairs even more rapidly (e.g., I’ve read about teams switching pairs every 90 minutes). If you’ve never heard of Promiscuous Pairing you can read about it in Arlo Belshee’s article.

    Conclusion

    Like everything in software development, Ping Pong Pair Programming is no silver bullet. There are times when pair programming may not make sense based on the task, the team personalities, etc. But I would strongly encourage you to try Ping Pong Pairing before deciding that pair programming is not for you.


    每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文,欢迎关注开源日报。交流QQ群:202790710;微博:https://weibo.com/openingsource;电报群 https://t.me/OpeningSourceOrg

  • 2018年11月3日:开源日报第240期

    3 11 月, 2018

    每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文,欢迎关注开源日报。交流QQ群:202790710;微博:https://weibo.com/openingsource;电报群 https://t.me/OpeningSourceOrg


    今日推荐开源项目:《可能是未来的 GitHub 的目录 GitHubNotes》传送门:GitHub链接

    推荐理由:如果你想在 GitHub 上指定查找某个方面的资源,比如导航栏库和进度条库这样的,那么就可以来看看这个项目。这个项目是作者为了整理自己给过 star 准备研究的库所创立的,里面按照各种各样的类型划分了这些库,比如之前提到的导航栏和进度条,如果需要像这样针对性的寻找某个具体类型的库的话,可以关注一下这个项目,兴许以后它就会成为一个 GitHub 的目录也说不定。


    今日推荐英文原文:《Job interviews for developers — 15 simple points to happiness》作者:Gergely Kalapos

    原文链接:https://kalapos.net/Blog/ShowPost/developer-interviews.html

    推荐理由:为了帮助其他开发者找到合适的公司,作者用这篇文章介绍了15个要注意的地方

    Job interviews for developers — 15 simple points to happiness

    I’m in the middle of switching jobs, so recently I had the opportunity to talk to a couple of companies. “Job interviews” was always a topic that I was very interested in, so I thought I summarize what I had learned over the years in a blogpost.

    My goal with this is twofold. First to share some specific points that help me to find the company that could be a great fit for me. Second hopefully others can also learn from this. I see so many articles from the “other side”, namely from recruiters and HR people. With this post, I’d like to describe how a developer sees this topic. Obviously, recruiters and HR people deal with this topic daily, and we (developers) don’t, so maybe I can help the community with this.

    My evolution with job interviews

    I had my first job interview about 13 years ago when I wanted a summer internship as a high school student. I still remember that my approach going into the interview was something like this:
    “Please, please don’t ask anything that I don’t know; it would be even better if you wouldn’t ask me anything. I know nothing, but please give me the job!”

    Obviously, this is terrible, but most people start like this.

    Now this time, about 13 years later, when I went into an interview, my approach was something like this:
    “This is me, this is what I can bring to the table, these are the challenges I’m looking for. Tell me what your product is and where you need help with it! If it seems to be a fit, then show me your product, show me the code and I’ll tell you what I’d do. After that, we’ll see if it’s still a fit.”

    Of course, there is more to it, but I think you already got the point: over the years I realized what’s important to me and how I should approach a potential future employer.

    Let’s get a couple of things out of the way

    One thing I’d like to clarify upfront is that this isn’t a review about companies that I interviewed with, so if you want to know which companies I talked to (this seemed to be an important question to people 🙂 -which it isn’t!– ) then you won’t find answers in this post.

    It would be simply unfair to openly write about my specific interviews including company names. I expect those companies to not write public blogposts about me being in an interview situation either, so it would be simply unfair from me to do that.

    The goal here is to share what I’ve learned over the years to help other devs find the right company.
    All right; let’s get started.

    1. General lessons

    First of all, I’d like to point out that finding the “best fit” heavily depends on your personality and your specific situation. I think the whole point of interviewing is to figure out if a candidate with her/his technical knowledge is a fit for the company and (I guess more importantly) if this candidate personally is a fit for the company and even more importantly (and this is what HR people always seem to forget): if the company technically and culturally is a fit for the candidate.

    2. Know what you want

    I noticed that the more specifically I know what I want, the easier the job search is. And by this I don’t mean that it’s easier to find companies; I rather mean it’s easier to filter out companies. Most of you know that I’m specialized on .NET and Microsoft technologies and, by reading this blog, you also know that I really enjoy creating content for developers. This includes blogging, creating tech videos, giving tech talks, creating online courses, etc. Consequently, I looked for a company that can use most of these skills, so I automatically filtered out companies that looked for devs, who sit in the corner all the time and just want to write code. Being a dev who only wants to write code is perfectly fine! It’s just not for me. The point is: figure out what you really want and be as specific about it as you can.

    3. Communicate clearly what you want

    Once you know what you want, it’s super important to communicate it clearly. My mission statement was like: “don’t hire me for just writing code, hire me for making your product successful in the .NET/Microsoft world”. Obviously, I’m a dev and I only applied to engineering jobs, so I always made clear that writing code is my primary skill, and I really enjoy doing it, but I also always stated out loud that I’d be pissed if I’d only have to code. I want to talk about the products that I create, I want to show them to the world and talk about them in videos, conferences, etc.

    Again, you don’t have to be the same – but you should communicate clearly what you want.

    4. Start before you need a job

    Now that you know what you want and how to communicate that the next task is to find companies that need people with your skillset and your “mission”.

    Finding “the right company” starts way before you realize that you are looking for a job. Some people suggest that you should maintain a good relationship with companies and colleagues from other companies because at some point you might need a job. I think this is a very selfish and bad approach.

    What I do instead is that I maintain a good relationship with colleagues and companies that do interesting stuff, regardless of the fact that I might need a job later. I do this simply because I can learn from them. (Well, ok, I’m a meetup organizer, so maybe I do this because I know that at some point I can use their office space as meetup location, but please don’t tell them!)

    I’m always open for learning new things, and I’m always happy to visit a company’s office, for example when they host a meetup. I think every developer should know what certain companies in the industry do and that way when you need a job you already know what companies could be interesting to you.

    In my last round of interviews, I knew all the companies that I interviewed with. I knew exactly what they do, and I also knew people from those companies. So, none of my interviews start with “We are company [X], let me tell you what we do!”. I always skip that part and I think that is a huge advantage.

    You can do the same: go to meetups, find interesting people on twitter and interact with them, contribute to open source projects, simply be part of “the community”! You will naturally end up with people that work on things that you find interesting.

    5. Avoid agencies, talk directly to companies instead

    Previously I had contact with a couple of recruiting agencies and it was always a waste of time, so very early in my career I decided to completely avoid them.

    The business model of these agencies is this: since developer salaries are relatively high, it is a lucrative business to recruit developers. Usually, a recruiting agency gets the equivalent of a couple of months’ salary per developer. So, their goal is to recruit as many devs as quickly as they can and generate a high turnaround in the area, so they can place those engineers to other companies.

    The problem is that they have no interest in finding a place where you can be happy and productive, for let’s say, 10 years – that’s not a good deal for them.

    Another fact you should consider is that sometimes companies give signing bonuses. Some people are hired directly, others through recruiting agencies. I have no data about the relation of those two groups, but I think we can have a very strong assumption that if a recruitment agency gets, let’s say, 5 months’ worth of salary for you from your future employer, then the company won’t feel too motivated to pay you another couple of months’ worth of salary as a signing bonus. Again: maybe I’m wrong, I don’t have data about this, but this is definitely something you should think about!

    Also, you should know that most top tech companies don’t even accept applications through random 3rd party recruiters.

    This one is for example from Google:

    Source: https://careers.google.com

    Here is what Amazon says about this:

    Source: https://www.amazon.jobs/en/faqs

    And I can go on with other companies. The fact is: if you go to a recruitment agency you won’t end up at those companies, simply because those companies don’t need the services these agencies offer.

    One exception is that some of those top tech companies work with “Recruitment partners”, but in those cases, they usually talk to you as the company itself and don’t even offer jobs at other companies – but this is a whole different story; this is more like recruitment outsourcing.

    Plus, there is a final reason I don’t work with agencies: our job is a fairly significant part of our lives. We spend more time with our coworkers than with our family. Therefore, it’s super important to me to talk directly to a potential future employer early on. I see no point in outsourcing this to an agency. Seriously, it’s like: do you send someone for the first 2-3 dates to precheck a potential partner? Well, maybe some of you say “yes”, but let me tell you: that’s not normal! 🙂

    Maybe there are good IT recruitment agencies out there and maybe there are scenarios where it makes sense to use them, but to me it never seemed useful, so I simply avoid them.

    Facts are: a) they generate costs for your employer and it’d be naïve to think that you won’t pay anything for that service and b) you will never get employed by a top company through a recruitment agency.

    6. Some dealbreakers

    There are a couple of things that count as red flag to me. One typical example is when a recruiter wants to know my current salary early in the process.

    It’s important to talk about money, but in the first 20 minutes of the very first call it’s just simply a sign that the interviewer wants to collect data. This is definitely something you should be prepared for. I think there is no right approach to this, the best thing to do is to be prepared and consequent.

    Another day, another interview tip. This time to #sourcers and #recruiter(s): If you don’t start the first call with “Hi my name is [x] from company [y], what is your current salary?” you are already in the top ~50%. Bonus: don’t call people “resources” – it sounds very strange.

    — Gergely Kalapos (@gregkalapos) October 4, 2018

    Here is what I do: I’m absolutely against this practice. If this happens very early I simply say: “To me, this is a red flag. Collecting such data is against my values. Thanks for your time, but this interview process is over” – and I simply drop out from the process.

    Btw. just think about it like this: as a dev you usually have access to sensitive customer and company data. I, for example, have had access to memory dumps from customers (yes, probably containing passwords!), to the whole source code of the company, potentially also code from customers. As a dev, you also usually know who the customers and prospects are. So, if devs give out their very own relevant private data so easily, then I don’t even understand why those companies think that they can trust them with the company’s and customers’ sensitive data.

    One last point to giving out salary information: usually if someone asks me about my previous salary then I simply ask their salary. Keep in mind: you don’t break the law by asking questions! It’s the opposite: the whole point of interviewing is to ask questions, and that is true for both sides. Asking the same question that the interviewer asks is also fine!

    I still remember when I was interviewed by 2 people with very high, fancy titles and they asked me what I earn. I simply said: “What an interesting question! Let’s talk on an equal footing! What is yours?” and I simply pointed my finger to one of them. Of course, there was 30 seconds silence and none of them gave out this information at the end. I didn’t do it, either.

    If they had answered my question, I would have been happy to talk about it myself, of course. Again: there is no law whatsoever that says you cannot do to them what they do to you. Almost every job offer nowadays says things like “transparency, openness, equality, open-door policy, flat hierarchies”. Well, based on the story above, all of those were bullshit at that given company – it’s nice to find this out way before you sign your contract.

    The other dealbreaker for me is, when during the interview process they forget to ask who I am and what I look for. Lots of interviews are carried out by other developers and they want to know whether the applicant is a good developer. This is absolutely a good thing, the only problem is that it’s not uncommon that you have a 1-hour interview scheduled and then you talk about technical stuff for 90 minutes (which is super cool btw, I always enjoy that!) and then they say “Ok, this was really good, we are overtime, do you have any question?”

    And then I’m like: “Yes, sure! What problems do you have currently? What are your values? Why do you hire? Who do your devs work for? -For a team lead? Product owner? CTO? For the actual user? (How radical that’d be!) Why do you have only white dudes in your management? Is everyone white dude? Do you want me to only write code? If not, then where can I help other than coding? Btw. I would like to talk about your product at conference [X], are you ok with that? Can I make YouTube videos about it?” …the list usually goes on… “And all that btw. you should answer in -30 minutes”.

    The point is: if the interview is structured in a way that the only thing they want to figure out is whether I’m a technical fit, then I automatically drop out voluntary. Again: we spend more time doing our job than with our family! It must be way more than “technical fit”!

    I realize that lots of candidates don’t care about these kinds of things, but if the interview has a fixed structure with “~99% of the time: we ask the candidate, and ~1% of the time: the candidate has the option to ask questions”, then to me it’s not a fit. Good interviewers can deal with this very well and they can spot if someone would like to have more than just an average 9-5 job. Side-note: looking for an average 9-5 is absolutely fine! The point is: offering simple 9-5 jobs and listing all the catchy buzzwords is bullshit and that you should spot during the interview process.

    7. Don’t try to change their processes

    There are different approaches that interviewers use. Some of them grill people on hardcore algorithm questions, some of them ask more behavioral questions, some of them have a set of values and try to figure out if the candidate shares the same values, and some of them prepare some random technical questions.

    Unless you talk to a very small company, or you are some super famous person, there is no chance that they’d be willing to change anything in the interview process just because you ask for it.

    Therefore, I usually let them do whatever they want to do with me – unless it’s physical torture. If they want to grill me on hardcode algorithm skills, I’ll play the game, and similarly, I’m also fine if they want to find out my values.

    Some candidates for example simply refuse to do whiteboard interviews.

    I think you should figure out if there is anything which is not uncommon in the industry that you are unwilling to do (like algorithms, whiteboard stuff, pair programming), and if there is something, then you should tell this upfront and drop out of the interviewing process very early. I’d suggest never going into an interview and then saying, “Well, I don’t do whiteboard interviews”. – Discuss this upfront!

    On the other hand, I make sure that everything I want to cover gets covered (see my 2nd deal breaker). So, I never ask companies to change the interview process, I simply ask for doing additional things on top, if they don’t cover important issues/questions.

    Maybe a couple of words on whiteboard interviews and typical “Cracking the Coding Interview” style questions: I know that lots of candidates hate them. I think those interviews are good for identifying pure brain power. You can figure out if someone is plain smart by asking those questions. However, you won’t be able to figure out if someone writes maintainable code, would be willing to mentor other people in a team, and you won’t find out if this person can ship a software product that actual users would be happy to use, either.

    And to me, the most troubling part is that sometimes companies completely misuse those types of questions. They simply think that those are ready-made questions and by asking those, you can completely assess a candidate. Now you, the candidate, can easily spot if an interviewer falls into this category.

    I repeat: there is no law whatsoever that says you cannot ask questions in an interview!

    Many times, a person with a fancy title comes in and asks questions that are literally in that book. I never judge interviewers, but sometimes I have a feeling that managers who haven’t coded in 10 years try to assess candidates’ coding skills, and I think that this is problematic.

    I simply call this “fake interviewing” – where there is nothing that you or they can learn in an interview, it’s simply doing it because some process says that it must be done and since there is this book, they quickly choose a couple of random questions. The problem is, the person with the fancy title won’t read the bad code that a person with great algorithmic skills, but no empathy for working on a 1mio lines of code codebase writes.

    Just to make sure this is not the case, I usually also prepare a couple of questions and I usually also ask something. Nothing big, I say things like “Ok, what if we have multithreading here and we have, let’s say, 10 threads doing this? I’m sure you as [fancy title] deal with this on a daily basis! Have you seen this problem? Would you mind talking about this for a minute and tell me what you’d do?”.

    Of course, I’m not stupid and I don’t try to generate conflict in an interview. I only do this if I have a feeling that the interview really has no clear goals. And of course, if I’m proven wrong, then even better!

    8. Look at the code!

    This, to me, is the most important part of a developer interview process! Yet so many companies and candidates forget about this – I also did early in my career.

    Today, one of my rules is that I don’t sing a contract until I don’t see the code – or at least some code that my future team wrote. Simply because I think if you work in an organization that deals with software, then the software must be a central point of the interview process. Not some non-real-world question from a book, or a discussion about how to clean all the windows in Seattle (*they usually substitute Seattle with their local city), or whether I use tabs or spaces – all those can be important, but not as important as the real product itself.

    To me, the most important question is: can I understand the code that the team wrote before I join, and, is there a potential for accomplishing some significant contribution in the future?!

    Also, I want to identify things that I can improve, or at least things where I can help. First, I try to understand the architecture and for that, I ask questions. I never blame people, and I usually literally say “I’m not here to blame, I’m just trying to figure out where can I help” multiple times. So, if the interviewer can’t explain the architecture then it’s fine, I simply move on and try implementing something – only a very small change or a tiny feature – and for that, I again ask questions.

    One thing I like doing – and this is probably a little bit mean – is that I simply plain-text-search for the word “todo” in the codebase. This is definitely a point where I loudly repeat that “I’m not here to blame…” – especially if I have 100s of hits in a ~5000 lines project that was already shipped to production (yup, that happens!).

    I usually also ask questions like: “Here is this constant, what’d happen if I changed it? Well, you know what, let’s change it and commit it with your user! What’ll happen? Do we automatically deploy into production? Will I see a failing test? Do you get an e-mail? When do you get response? In 1 minute? 1 hour? 1 day? Really 1 day? Don’t you think we should work on CI/CD first, instead of adding .NET support? – btw. I’m happy to help with that!”. Again, here the point is to figure out the dynamics within the team and to see how the team works. I’m clearly unhappy if there is no CI/CD, but instead of blaming, I simply offer help and see if they are willing to take that.

    Doing these kinds of things on a codebase gives you a very good impression about the overall quality and about how people in the company work.

    Also, if you are interviewed by senior engineers, architects, some kind of leads for a normal engineering role and you see that their code is full of TODOs, no one can explain you the architecture, and they don’t even have a proper CI/CD system, then they clearly have a title inflation. If you think you can really establish much better software engineering practices, then in such a situation, you can communicate clearly how you’d help them and what organizational changes that’d require.

    Of course, it can also be the other way around! Maybe you learn a bunch of new things, you see a super cool CI/CD system combined with containerization, which tests your code in countless environments. In those cases, the answer to my question “What if I change this constant and commit?” is usually something like this: “In less than 1 minute I get an email and that commit can never end up in master, feel free to test it!” – that’s a good sign and no “Cracking the Coding Interview” question can give that feeling!

    Another #interviewTip, this for #Dev(s): Let them do their #interview process as they want (algos&datastructs,behavioral,etc),but make sure you look at their code❗Ask questions & try implementing something. If you can navigate through the codebase it’s a fit, otherwise it isn’t.

    — Gergely Kalapos (@gregkalapos) 5. Oktober 2018

    Now, probably most of you think: this sounds nice, but doing this is very hard and timeconsuming! Well, yes! Guess what, interviewing is very hard and timeconsuming! The question is, do you spend time faking stuff or do you want to talk about real things? Also hiring someone after a “fake” interview, and then figuring out after, let’s say, 5 months that this person can’t really add value is significantly more timeconsuming.

    Also, there are open source companies or companies that opensource at least some part of their code. This means you have full access to the codebase before the interview. Sometimes issue tracking, including interaction between team members, is also in the open! From the candidate’s point of view, these companies are like wonderland! Of course, they already realized this and it’s not uncommon that open source companies hire contributors. In that case, the interview process is usually exactly like what I described above – the difference is, it doesn’t start as an interview.

    9. Get to know the team, not the [fancy title] manager you’ll never work with!

    This point again goes back to the fact that we spend more time within the company than with our family.

    Very often interviews are carried out by some manager you’ll never work with. Plus, there is the Google-style of hiring, where you don’t even know in which team you’ll end up.

    However, there are companies where the whole team interviews the candidate and the candidate also interviews the whole team.

    I think the clear consequence of the first approach is that you will still have no idea about the dynamics within your team when you sign your contract. Also, you cannot assess your level within the team if you don’t talk to the team, and believe me, the high-ranked manager can’t do that, either, because this person never works with the team – definitely not on a daily basis, spending hours with them every day as you’ll do.

    Maybe the team member who will sit next to you is a terrible person, or isn’t a terrible person, but this is someone who you’d never work with – people can be incompatible! It’s very bad to find this out on your first day.

    The other problem is bias: if the decision is in the hand of a couple of people then the team setup will reflect their biases. – Just a personal note: you, dear reader, were with I’d say 90% probability selected by a white dude. Most of your co-workers are also white dudes. You get the point.

    Think about this: if you are within a team, you look for someone that can help you solve the team’s problems, write code you can easily understand, and can also understand your code easily. You don’t care about all those “Cracking the Coding Interview” questions, because you look for someone that can build a product with you. Also, if people with less experience have a vote, than they will naturally look for people that can teach and mentor them.

    The high-ranked manager cares about very different things. If the code of the candidate is not readable, then their daily life is not affected – it’s very different, if every team member votes!

    Hiring for ‘top talent’ == fixed mindset.

    True leadership is building great teams. Not hiring so-called ‘top talent’

    — Raphael Haddad (@RaphHaddadAus) 13. Oktober 2018

    Now what does this mean for you, as a candidate? This means that if you see an interviewer then try to figure out if you’ll really work with this person or not. If the answer is no all the time during the interview process for every interviewer, then try to ask them to introduce you to your future colleagues before you sign your contract.

    I think you already figured out my opinion: I have a clear preference for an interview style where the candidate meets the whole team and everyone has the same vote, no matter what title they have. Why? Because the decision directly affects the lives of people making the decision! – If you see “flat hierarchy” in the job advertisment and they don’t do this, then that catchy phrase is an obvious bullshit.

    10. Make jokes

    Besides technical fit it’s very important to figure out if there is a cultural fit between you and the company. To figure this out, I usually make some jokes in the interviews and carefully observe the reaction.

    It’s very common that the recruiting department advertises the company with things like “we like to have fun while we work” – well, almost everyone wants that, but very few people have it!

    You can spot people who don’t have fun by not being able to handle jokes while they are working.

    One of the best experience in my recent rounds was when I told a potential future boss that they “can have very high expectations if they hire me, but definitely not on Monday mornings”. This is not my best joke, but in a dead-serious interview, this is really unexpected – the result was that we had to make a short break, because they laughed so hard, they were unable to speak.

    This, to me, meant that people in that company really can have fun – and obviously they also noted that I’m not a morning person.

    2 highlights from my recent job interviews:

    -Me to potential future boss: you can have high expectations, BUT NOT ON MONDAY MORNINGS!

    -Me to CTO: If the company goes public, can I ring the bell on the exchange? I wanna ringt the bell! Can I ring the bell?!

    — Gergely Kalapos (@gregkalapos) 3. Oktober 2018

    So, my suggestion: try to create “unusual” situations during the interview to figure out the real personalities of your future bosses and colleagues. This is useful information, plus very few people do this. If the “we have fun” propaganda is true, then you prove them you really like having fun. Of course, I assume here that you really do like having fun.

    11. Ask unpleasant questions

    Besides having fun, I also try to make sure that my interviewers can take criticism. This goes back to the catchy words like “flat hierarchy, openness, equality, transparency, blah, blah, blah”.

    Before one of my interviews I went to glassdoor.com and noticed the company had very bad reviews. This was clearly a bad sign, but I always try to make sure that I don’t judge too early, so I decided to use those reviews as my “unpleasant question”. I told them I have seen lots of bad reviews and I would be super happy to help make sure that people don’t feel so bad within the company. Then I started quoteing a review and saw that the face of the [fancy title] interviewer started turning red.

    The reaction was that “all those reviews are stupid” and I “should ignore them”. Based on my values, this is clearly the worst way a management can deal with criticism. Furthermore, you should also keep in mind that if you got hired, then probably you will also bring up a couple of things if you truly want to achieve something – and probably the reaction will be the same: it’s “stupid” and everyone should “ignore it”.

    Btw, glassdor.com reviews aren’t the only way to do this. Big companies usually had some scandals in the past, it’s also good to bring those up.

    Another problem that almost every company has, is the so called “white dudes only management, except the head of HR”-problem. If you think this is not ok, then simply bring it up!

    These are all things where there is no good or bad answer, the important thing is the reaction itself. Are they open to discuss it? Sometimes they are aware of the problems, and they even try to work on them. Saying “It’s stupid; ignore it!” is very different from saying: “Yes, this clearly is a problem, and we would like to solve it! Would you help us? We have a task force working on it, would you join if you got hired?”.

    12. Salary

    Salaries is a huge topic on its own and there are other people who know more about salary negotiations than I do.

    Here is what I usually do: by doing some research, you usually know what developers earn in your area. During the interview process you can also identify where you can help the company and where you would fit based on your knowledge and experience.

    If you think you can really fill a gap, then you are probably worth more money to them.

    I always make sure that I don’t price myself out of the market, so I always tell a realistic number. Just to be clear: unless you are in Silicon Valley, or you do some quantitative finance development at a hedge fund in Singapore, you won’t have a 300K USD base salary as a developer.

    However, if the reaction to the realistic number is that they automatically start negotiating down with some fake arguments, then I simply say: “Thank you, but I’m afraid we won’t reach an agreement here” – and I end the discussion, because I don’t want to work there. My idea behind this approach is that today we have a market where almost every company has to fight for good talent. If I stay within the current market rate, and they are still not willing to pay that amount, then they won’t raise my salary after 1-2-3-4 or 10 years later either, plus, my collogues probably also earn below average and that’s not a good sign.

    For the sake of completeness: a non-fake reason for offering less than you asked for would be if they’d give you the compensation list and they say: “well your interviewer is on level X, we think you are a little bit below that, and the top salary we give on that level is 5% less than what you ask for”. Do companies do this? 99% of them don’t. But there are some real pioneers: for example, StackOverflow has an open compensation scheme, and Buffer also publishes its salaries. Now that is what I call transparency!

    13. Job titles

    I see a huge chaos in the industry when it comes to job titles, with a little bit of title inflation on top of that. Therefore, I usually ignore titles at the beginning, and I simply ask the interviewer to define what they mean by a specific title. This seems silly, but so many times I see sales and marketing people running as “engineers” and people doing administrative things as “managers”. There is nothing wrong with this, as long as everyone speaks the same language. So, make sure you speak their language!

    A typical example for this is the title “architect”. I had my first internship when I was 15, and after 14 years in the software industry I still don’t really know what an architect does. At the beginning I thought that they deliver architectural design and documentation but let me tell you: in 14 years I have never got anything architecture related from an architect, so I’m probably wrong. If you ask me “what an architect does?” I’d say it simply depends on what the definition of an architect is in a given company. Btw, I know that there are different kinds of architects, but to me those specific “architect” titles don’t mean too much either.

    So, the bottom line is: title doesn’t matter and doesn’t guarantee anything; you can be called “code monkey” and still do awesome things! Your job during the interview phase is to figure out what the meaning of certain titles at the given company is – with that you can avoid huge disappointment later.

    Another thing I noticed recently is that some people go by multiple title. Usually when they talk to customers, they are something with “senior”, or “lead”, or something catchy, but internally they have a totally different title.

    I suspect that those people are paid by their “lower” title, and I find this a very annoying practice in general. If you see this at the company that you interview with you’d better clarify this upfront.

    14. Seniority

    My goal in an interview process is to identify people who are somewhat above my level (aka I can learn from), but also to find people who are somewhat below my level (aka I can teach) when it comes to technical abilities – btw. this is not black and white! Sometimes you learn from someone and in the next minute you teach something to the same person, so don’t be too focused on that, the point is: figure out where you’d fit compared to your interviewers.

    I don’t really care about the title “senior”, but it’s important to me if the company has a hierarchy, then I end up on a realistic level.

    Btw, being senior also means different things at different companies. Some companies call almost everyone senior and some other companies don’t even have “senior” titles.

    To me, the easiest way to find a common vocabulary is this: try to figure out what is the average developer salary in your region. If they offer a salary below that, then you deal with a junior position, if they offer something that is near the average, then it’s a regular developer job, and if they offer significantly more than the average, then it’s a senior position.

    Of course, they can call you a “senior engineer” with a below-average salary, but in that case, you should know that they have title inflation and considering the market you aren’t really senior and it will be hard to find a “senior” job at another company – unless you are really senior, but in that case: leave NOW!

    Similarly, being a “junior engineer” with an above average salary means that they have very high standards, and you can have a higher title at another company with high probability. Is this bad? I don’t know, not necessarily. If you are happy, and your position in the organization is realistic then I don’t think this is tragic. To me, title doesn’t matter, the question is: does it matter to you?

    Now one exception where my theory breaks, is early stage startups: they probably won’t be able to pay above average developer salaries, even if you are clearly “senior”. And by the way asking for an above average salary at a startup isn’t a good idea, either, since those usually don’t have the cash flow to pay it and it’d put the finances of the company at risk. So, my theory doesn’t apply for startups. Btw, if you feel you are “senior”, then in case of a startup you can ask for equities. In Europe, we have terrible moral when it comes to equities in startups (aka: none of them wants to give equity), but I see some positive signs, and if you are good, they have to compensate you somehow – so shoot for more equity!

    Another thing to be aware of is that consulting companies usually have a staff where basically everyone is senior. It’s not uncommon that services done by senior people are sold on a higher rate than services by non-senior people, and the consequence is that – guess what! – everyone is hired as senior.

    I personally would not play this game, so if I don’t feel that I’m good enough for the title, I then wouldn’t go to a customer and bill the higher rate – this is just plain wrong. But again, this is just my opinion. The point is: be aware of this and prepare upfront.

    15. Have money!

    The goal of all my points above is definitely not to find a company as fast as possible. They are all about finding the right company. In fact, by being consequent in all those points, you will probably drop out from multiple hiring processes.

    If you live paycheck to paycheck, you cannot afford to look for a job with the proposed approach, simply because your goal will automatically be to find a job, no matter what – and not finding the right job.

    “Having money” again is a topic that can easily fill a whole book. What I want to say is that it definitely makes sense to “invest in your freedom”, and by this I simply mean that you should always have enough money so that you can survive without a job for a certain period of time. The length of this time-period is up to you. Some people feel safe if they have enough money for 3 months without a job, others shoot for a sum that covers 10 years without any income. There is no universal answer, the point is: make sure you never accept a job or a job interview process just because you need money.


    每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文,欢迎关注开源日报。交流QQ群:202790710;微博:https://weibo.com/openingsource;电报群 https://t.me/OpeningSourceOrg

  • 2018年11月2日:开源日报第239期

    2 11 月, 2018

    每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文,欢迎关注开源日报。交流QQ群:202790710;微博:https://weibo.com/openingsource;电报群 https://t.me/OpeningSourceOrg


    今日推荐开源项目:《自己家的 HTML 和 CSS PureCSS-Font》传送门:GitHub链接

    推荐理由:相信大家已经对这个画的各种画的作者有了深刻印象了,那么这次要介绍的就是纯 CSS 字体项目,你可以拿去放在各种各样的地方,不管是防止被复制粘贴带走你的文档亦或者别的用途都可以,如果你输入文本转换之后看看那几个字的 CSS 样式表……即使是写下几个字母,需要的样式表都会非常的长,顺带一提,不支持中文。


    今日推荐英文原文:《The Efficiency In Coding Strictly》作者:Isaac Way

    原文链接:https://medium.com/@isaaccway228/the-efficiency-in-coding-strictly-e79beceafa05

    推荐理由:如果一个项目需要编写大量的代码,严格的结构化的语言会相当有帮助;但是如果它是一个新的尝试或者不需要编写太多代码,放弃结构将会是个好主意;在编程中需要灵活选择它们,作者在这篇文章中就介绍了选用严格结构化的语言与否会造成的一些影响。

    The Efficiency In Coding Strictly

    Before I get into what it could mean to code “Strictly” or even “Efficiently”, I’m first going to tell you just a little bit about my coding experience so you know where I’m coming from.

    Static Vs. Dynamic

    I’ve spent significant time coding in both dynamically typed and statically typed programming languages. For anyone who doesn’t know, statically typed languages (C, C++, Swift) are, generally speaking, languages that require the developer to give a variable a type when it’s declared. A dynamically typed language like (Python, Javascript) does not require you to specify a type for every variable. I don’t know exactly how much time I spent in these languages exactly, but if I had to guess I would think it’s split pretty evenly. ⅓ of my time was in C/C++/JS, and ⅓ of my time was spent in each of Swift and Python. I say this just to make the point that I have no preference among these languages, I use whatever I need to use to make whatever it is I need to make. Personally speaking, I very much enjoy coding in both Swift and Python which are both at opposite ends of the spectrum as far as strictness goes. C/C++ I don’t enjoy as much, but they’re cool but in the same way that a game boy color is cool. Don’t get me wrong, those languages are necessary in some areas of software even today, but they’re not “easy” to get things done compared to something like Swift, or Python.

    For highly streamlined things like developing an high performing iOS app, where we know exactly what is expected, we tend towards a strict structured approach that assures quality if done right. On the other hand, if I were a researcher using Python I wouldn’t know what’s going to happen before hand. In this situation, it doesn’t make sense to have a strict structure because I don’t have a long term idea of what the process will look like and it changes day to day. Therefore, the highly flexible structure of something like Python allows you to quickly respond to these changes, and designed patterns that make doing some things easily suddenly start to make a lot less sense presented with the new situation. The code that the researcher would be writing is not a large and complicated system typically, rather it’s a few well thought out scripts and visualizations.

    Being Strict Reduces Our Workload

    When there’s not as much total code, it’s significantly easier to get it right as well as debug it. It’s easier to know what your variables are without being explicit. So we don’t need the strict structure in these situations, it serves us no benefit at all. If anything, trying to put this ill-defined process of research into a well defined design pattern might hurt us. That is why we need languages like Python, for when our tasks require high degrees of flexibility and problems that may not as easily be solved with a previously used solution. For any time we explore something new we necessarily must discontinue being strict, because if we are being strict we are using a predefined structure, and since the thing is new it is impossible to know it’s real structure. So Python throws away the structured approach and presents you with the minimal logic needed to create a working program, making it as easy as possible to make changes and bring in new ideas.

    But It Also Limits Our Flexibility

    On the other hand, the lack of structure in Python makes it relatively inefficient (when compared to something like Swift) at things where the requirements are always known beforehand, when the problem is known to fit a design pattern we can easily employ. The example I go back to an iOS App. If I’m using xcode to create GUI (Which is the native and preferred way to work in Swift) and link it to swift code, it is incredible to me that I can get a good looking, working App running in just a few hours of work. It may not do anything useful at that point, but it looks good, and it freaking works. That’s more than I can say about my experiences creating a Python GUI.

    “Strict”

    Prototype iOS UI Made In Swift. Took a few coding hours in total. ~140 lines of code.

    One of my personal projects over last summer was a visualization tool that was to be made entirely using Python’s built in libraries. That means, using tkinter to create a GUI. I’m not saying it’s a good idea to use tkinter in a serious application, or any application for that matter, but the point is it’s not “strict”. It doesn’t make you use a specific design pattern or require you to structure your app in a certain way, it just gives you UI objects to work with and you place them within your app using various methods. The result was to make just a single UI, it took me weeks. I had to code UI elements from scratch (Which is fast in swift because the design patterns it makes you use, but slow in tkinter because it’s not made to use any specific design pattern). I had to code a grid system in that worked with tkinters. The code got ugly, fast. In the end, I ended up with something that’s usable but definitely not the prettiest, and not the most maintainable. And that is exactly what happens when I’m coding “not strict” when I should be coding “strict”. I waste a huge amount of time, I end up with something that’s hard to make sense of later because it’s so dissimilar to anything I will make in the future. I’m not saying it wasn’t worth doing, because I learned some important lessons as well as made something kind of cool. My goal was not to be efficient in making a valuable piece of software. If it had been, it would’ve been a much better option to be more strict and find a more suitable tool for the job. To make the exact same kind of tool with the same if not more capabilities would take a fraction of the time creating it using Swift. Although I haven’t actually done it as an iOS app in Swift, I would think it would take a few days at most.

    “Not so strict”

    Visualization tool written in Python using Tkinter. It took weeks of a few hours of coding a day. It totals over 500 lines of code. The majority of the time was spent implementing custom UI elements. I was required to create in code the logic for the table and how the rows were displayed. It required much more work that I would not have had to do, had I created the same application in Swift.

    We can never be 100% strict if there exists no structure to make sure that we’re strict in any given situation. The language Swift presents a very structured approach to solving every single problem, and checks that it’s correct. In that way, the compiler combined with the design patterns in the language assures we are strict. It does so to such an extent, that the very process of creating something new becomes much faster. It eliminates a huge number of would-be developer errors, it assures that a familiar design pattern is used to solve the problem. The problem with this approach is, it is limited in what you can do and how you can do it: you cannot easily go outside the predefined structure. However, the structure can be expanded. What that means is, by implementing new problem solving capabilities within an inherently efficient set of rules, we necessarily make solving that problem faster than a less efficient set of rules. In a perfect world, every problem would have a “strict” solution, a solution that is already defined. But as we all hopefully know by now, the world isn’t perfect and neither are our solutions, so we are forced to find a balance.

    Coding Strictly might mean using a statically typed programming language, but more generally it means knowing how solutions are going to be implemented ahead of time and making sure that the solution itself has been proven to work well, and then implementing that solution to a T. If we’re in a situation where efficiency and productivity matter we should be strict, but only if we are certain we actually have a suitable strict solution. Whether it’s a strict situation or a not-strict situation, well, that’s a decision best made by the developer at hand.

    I hope you enjoyed this article. For any feedback please comment, for anything else email me at [email protected]. Thank you!


    每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文,欢迎关注开源日报。交流QQ群:202790710;微博:https://weibo.com/openingsource;电报群 https://t.me/OpeningSourceOrg

  • 2018年11月1日:开源日报第238期

    1 11 月, 2018

    每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文,欢迎关注开源日报。交流QQ群:202790710;微博:https://weibo.com/openingsource;电报群 https://t.me/OpeningSourceOrg


    今日推荐开源项目:《别人家的 HTML 和 CSS(Ver3.0) purecss-zigario》传送门:GitHub链接

    推荐理由:又到了观赏艺术的时间了,还是同一个作者,还是同一个规矩。这次的作品是一个中世纪风格的香烟广告,说真的每次看到那句完全使用 HTML 和 CSS 手工编码,然后看看之前自己练手时写下的东西……能做出这些作品的人,真乃神人也。

    观赏链接:https://cyanharlow.github.io/purecss-zigario/


    今日推荐英文原文:《Why engineers need to know human rights》作者:DigitalAgenda

    原文链接:https://medium.com/digitalagenda/why-engineers-need-to-know-human-rights-347e6e7cb8b0

    推荐理由:为什么需要工程师了解人权?这个问题的答案很简单——技术本身并没有错,但是如果不能正确的使用技术,那就会产生错误

    Why engineers need to know human rights

    Technology dominates our lives — and can transgress all kinds of legal frameworks. That’s why we should teach human rights law to software engineers, says Ana Beduschi.

    Artificial intelligence (Ai) is finding its way into more and more aspects of our daily lives. It powers the smart assistants on our mobile phones and virtual home assistants. It is in the algorithms designed to improve our health diagnostics. And it is used in the predictive policing tools used by the police to fight crime.

    Each of these examples throws up potential problems when it comes to the protection of our human rights. Predictive policing, if not correctly designed, can lead to discrimination based on race, gender or ethnicity.

    Privacy and data protection rules apply to information related to our health. Similarly, systematic recording and use of our smartphones’ geographical location may breach privacy and data protection rules and it could lead to concerns over digital surveillance by public authorities.

    Software engineers are responsible for the design of the algorithms behind all of these systems. It is the software engineers who enable smart assistants to answer our questions more accurately, help doctors to improve the detection of health risks, and allow police officers to better identify pockets of rising crime risks.

    Software engineers do not usually receive training in human rights law. Yet with each line of code, they may well be interpreting, applying and even breaching key human rights law concepts — without even knowing it.

    This is why it is crucial that we teach human rights law to software engineers. Earlier this year, new EU regulation forced businesses to become more open with consumers about the information they hold. Known as GDPR, you may remember it as the subject of numerous desperate emails begging you to opt in to remain on various databases.

    GDPR increased restrictions on what organisations can do with your data, and extends the rights of individuals to access and control data about them. These moves towards privacy-by-design and data protection-by-design are great opportunities to integrate legal frameworks into technology. On their own, however, they are not enough.

    For example, a better knowledge of human rights law can help software developers understand what indirect discrimination is and why it is prohibited by law. (Any discrimination based on race, colour, sex, language, religion, political or other opinion, national or social origin, property, association with a national minority, birth or other status is prohibited under article 14 of the European Convention on Human Rights.)

    Direct discrimination occurs when an individual is treated less favourably based on one or more of these protected grounds. Indirect discrimination occurs when a rule that is neutral in appearance leads to less favourable treatment of an individual (or a group of individuals).

    Similarly, understanding the intricacies of the right to a fair trial and its corollary, presumption of innocence, may lead to better informed choices in algorithm design. That could help avoid the possibility that algorithms would presume that the number of police arrests in a multi-ethnic neighbourhood correlates with the number of effective criminal convictions.

    Even more importantly, it would assist them in developing unbiased choices of datasets that are not proxies for discrimination based on ethnicity or race. For example, wealth and income data combined with geographic location data may be used as a proxy for the identification of populations from a certain ethnic background if they tend to concentrate in a particular neighbourhood.

    Likewise, a better understanding of how legal frameworks on human rights operate may stimulate the creation of solutions for enhancing compliance with legal rules. For instance, there is a great need for technological due process solutions, by which individuals could easily challenge AI-based decisions made by public authorities that directly affect them. This could be the case of parents who would be wrongly identified as potential child abusers by opaque algorithms used by local authorities.

    Such solutions could also be relevant to the private sector. For example, decisions on insurance premiums and loans are often determined by profiling and scoring algorithms hidden behind black boxes. Full transparency and disclosure of these algorithms may not be possible or desirable due to the nature of these business models.

    Thus, a due process-by-design solution could allow individuals to easily challenge such decisions before accepting an offer. As our contemporary societies inexorably evolve towards intensive AI applications, we need to bear in mind that the humans behind the AI curtain have the power to make (mis)informed decisions that affect us all.

    It is high time that resources and energy are reverted towards educating them not only in cutting edge technology — but also on the relevant human rights rules.

    Ana Beduschi is a senior lecturer in law at the University of Exeter. This article is republished from The Conversation under a creative commons licence.


    每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文,欢迎关注开源日报。交流QQ群:202790710;微博:https://weibo.com/openingsource;电报群 https://t.me/OpeningSourceOrg

←上一页
1 … 199 200 201 202 203 … 262
下一页→

Proudly powered by WordPress