
Ask HN: What programming skills are required by HFT or Trading firms - mraza007
What are some skills required to land a job in Trading Firm especially in roles like DevOps or developing software. How can a person excel at the technologies required by these firms
======
pjmlp
Basically Java, .NET and C++, with heavy focus on C++.

Being able to write allocation free algorithms, even on GC languages, lock
free data structures and good knowledge of all multi-core programming
paradigms and distributed computing.

Here are some talks that will give you a small overview into that world,

CppCon 2017: Carl Cook “When a Microsecond Is an Eternity: High Performance
Trading Systems in C++”

[https://www.youtube.com/watch?v=NH1Tta7purM](https://www.youtube.com/watch?v=NH1Tta7purM)

Core C++ 2019 :: Nimrod Sapir :: High Frequency Trading and Ultra Low Latency
development techniques

[https://www.youtube.com/watch?v=_0aU8S-hFQI](https://www.youtube.com/watch?v=_0aU8S-hFQI)

Open source Java HFT code from Chronicle Software,
[https://github.com/OpenHFT](https://github.com/OpenHFT)

"Writing and Testing High-Frequency Trading Engines", from Cliff Click

[https://www.youtube.com/watch?v=iINk7x44MmM](https://www.youtube.com/watch?v=iINk7x44MmM)

However in these domains every ms counts, even how long cables are, so also
expect Verilog, VHDL, and plenty of custom made algorithms running directly on
hardware.

"A Low-Latency Library in FPGA Hardware for High-Frequency Trading"

[https://www.youtube.com/watch?v=nXFcM1pGOIE](https://www.youtube.com/watch?v=nXFcM1pGOIE)

You can get an overview of the typical expectations here,
[https://www.efinancialcareers.com/](https://www.efinancialcareers.com/)

~~~
willcipriano
> allocation free algorithms

Do you have any good sources for information about this concept? I'm having
trouble understanding how a algorithm could produce useful work without
allocating anything.

~~~
jacoblambda
Not an expert by any means but another way to look at "allocation free"
algorithms is by looking at them as "statically allocated".

They don't allocate any new memory but they do perform operations on an input
and write it to an output. At least in the embedded world this is how this is
often done. Considering the overlap between embedded software and HFT, I'd
imagine most of these algorithms are going to be something along the lines of
"Take in a massive but fixed size block of read only data and output a fixed
size result." You can have allocated memory but it needs to be allocated at
startup and be able to be consistently reused without need for reallocation.

If you want super low latency, the last thing you want is a memory allocator
blocking in the middle of your highly optimised algorithm. Instead you
allocate everything ahead of time and just reuse the memory over and over
again.

~~~
realtalk_sp
Exactly this. It's annoying but also not as intractable as it sounds. NASA has
a similar requirement for mission critical software operating under strict
constraints.

------
brianolson
Moral flexibility and subjugation. The boss says to build a thing, you build
the thing. If rewriting an infiniband driver and pinning it to a core on the
server and processing requests in kernel space in exquisitely crafted C is
what cuts reation time by 0.0000005 sec and makes the firm a few extra bucks,
that's what you do.

I interviewed at a Manhattan HFT firm (~2015) and that's what they do. The
boss noted that "Congress could make a law invalidating our business model"
and I realized that would be a good idea. They're not making the world a
better place; they're not providing a valuable service; they're just
exploiting and extracting and skimming some dollars out of the market. They
have money and they're in the right place so their money can grab more money.

~~~
SkyMarshal
Which would you say is more morally problematic, HFT or figuring out ways of
making people click ads?

~~~
ScottFree
The entire financial sector. It captures 30% of all corporate profits in the
world economy. Ads are bad, but not "take 1/3 of what other people make" bad.

~~~
3fe9a03ccd14ca5
You’d figure bank stocks would be performing better, considering they’re
capturing so much purported profits.

~~~
parenthesis
In many listed financial companies it is certain employees and management who
do well financially, rather than the shareholders.

~~~
sweeneyrod
As Matt Levine puts it, investment banks are kind of like socialist
collectives run for the benefits of their workers.

------
hft09876
I've worked at two of what are broadly considered to be the top firms. Most of
these comments are inconsistent with my experience.

Everybody's talking about what it takes to write trading systems, but OP asked
about "skills required to land a job" not skills needed to do the job. Aside
from a few specialized roles (like FPGA dev or security), the firms I'm
familiar with only evaluate general dev skills. The interview process is
pretty much the same as you'd experience at a top tech company. They don't
care at all if you know the languages they use. Once you're in the door, the
firm will teach you everything you need to know.

~~~
derivativethrow
Which firms are broadly considered to the top ones?

~~~
nwsm
Two Sigma, Renaissance Technologies possibly. Jane Street like the other reply
mentioned

~~~
mraza007
What about Bridge water and Hudson river trading

~~~
JAlexoid
Bridgewater is not an HFT, they are a hedge fund.

That being said - Bridgewater are looking for more than just skills.
Bridgewater is very heavy on meetings and those meetings being recorded. You
can ace the skillset, but would be completely inadequate.

Their interview process is great. It's very honest and revealing. I don't fit
the company and I made the decision at their campus interview, their opinion
matched mine as well.

But, unlike most other companies, you are shown exactly what the company is.
Which is very good.

If you can land an interview, you like them and get an offer - I hear that
it's a pretty good place to work.

------
pclmulqdq
I can only speak to HFT.

For dev roles, Python experts (emphasis on expert) and experts in modern C++
have the easiest time. C experts and systems programmers with assembly
expertise can also find a job, but the market is smaller for them (although
higher-paying).

OS-level and systems programming are valuable. Understanding computer
architecture is important, and computer systems as well.

Credentials are an important filtering mechanism for them, so if you didn't go
to a top 10 school, your resume needs to make up for it (or you need to be a
very experienced hire). Working at a FAANG company or a bank doesn't
necessarily make up for not going to a top school.

Successful devs at HFTs usually have a ~50-hour workweek or are very efficient
programmers.

~~~
mraza007
I wonder How can someone become an expert at python. Even though i have worked
for two global banks as an intern but now I’m exploring to land a position in
HFT to gain more financial/tech experience to become more well rounded person

~~~
efxhoy
I've written python for a living everyday for a few years now. No means an
expert but IMO there are two core skills:

Cleanliness and design. Learning and using language features that make code
easier to build on, test, and deduce about. Basically writing code that's very
nice to humans. Here python really shines.

The second part is writing code that's very nice to machines and runs really
fast and correctly. Multiprocessing, writing parts of the code in a compiled
language for extra speed, using buffers for speed, async, that kind of thing.
Easy enough for specific problems, the issue is that these performance tweaks
often make code harder for humans to understand.

Now writing a nice looking and well designed program is fairly easy. Making a
really fast-but-ugly program is also fairly easy. The mark of a real expert in
my opinion is combining these two abilities: writing code that's both human
and machine friendly. As always, practice makes perfect.

To practice you need to practice both, and on real data. Don't just use toy
examples, get your hands on some big messy data that takes hours to crunch.
Don't just write toy apps, keep writing and adding features until it becomes a
huge stinking mess, then learn from that mess and do it again.

~~~
mraza007
Agreed. I totally agree with unless you aren't willing to try you can't really
learn so pratice really matters

------
emidln
The three biggest skills aren't directly tech: learning fast/efficiently,
communication and execution under pressure, and perseverance/discipline to
finish/deliver.

Where I work, our devops use a mix of python/ruby/golang/bash for day to day
debugging and development. Ability to read, understand, and modify Python (or
a similar scripting language) and a familiarity with Bourne/bash are probably
the minimum for devops.

For operations, you'd want to bring some skills that add to the team in new
skills or redundancy. You'll likely be trained/cross trained in many more.
Familiarity with and ability to debug some of the following: databases,
networked services (sometimes a pcap replay is all you have), systems
troubleshooting, monitoring, queues, or specific hardware and software
platforms we use.

At the HFT I work at, we hire Jr and Sr people. For systems people, there is a
bit of a divide between trading systems engineers, who work directly with devs
and traders on the care+feeding of some corner of our software stack and
infrastructure systems that provide shared tooling and substrates (k8s,
deployment tooling, continuous integration/delivery, configuration management
tooling, additional debugging help, etc). We also have network teams,
traditional IT service desk teams, and performance monitoring/improvement
teams.

If you're not coming from trading, we still need all of the standard sysadmin
and devops skills. We have SSH, Kafka, Zookeeper, MySQL/Maria,
tcpdump/wireshark, Linux, Puppet, Docker, Kubernetes, ElasticSearch, Hadoop,
etc. We have misc custom file formats but also loads of json , some xml, etc.
We integrate open source and proprietary as much or more than we build.
Outside of the execution stack, you'd recognize a lot of what we do at any
medium-sized tech company.

If you want to talk about life at an HFT, my email is in profile. I came into
HFT as an experienced hire from the startup world and currently do builds
development.

~~~
mraza007
Hey thanks for sharing I’ll send you an email and i would love to know more
about HFTs since I’m currently an undergrad working for a financial company as
intern at the moment and graduating soon On the side I’m exploring different
career options and one of my top choices is to learn more about HFTs

------
organicfigs
I passed the interviews at one of the top stat arb hft firms and it sounds
like there are a couple of responses from similar shops here. One thing people
haven't mentioned: pedigree. I passed 3 rounds of interviews and my final
interviewer was batting for me, when I didn't get the offer, he said the team
was apprehensive because I didn't have the pedigree from MIT/Princeton like
everyone else. He wasn't a fan of the decision because he worked at a string
of failed startups himself prior to starting there, c'est la vie. Also for the
curious, he said the salary range was 400-460k with ~3-5 yoe.

~~~
rokobobo
A hiring partner at an HFT firm once told me why they had a disproportionate
number of people from MIT or Ivy League schools, especially for fresh grads:
they selected for intelligence, coding skills etc., but they also needed
people who could very quickly focus on the top priority tasks for the firm.
(For example, if someone committed buggy code and the firm was losing out on
profits because its algorithms weren't running, do you hunt down the bug or do
you revert?)

And it turns out that kids from Ivy League schools tend to be very good at
constantly being aware of these top-level priorities for the firm. This
applied for almost every front and mid office role in that firm: DevOps,
algorithm developers, traders, researchers. I can't speak for all the firms
out there, but I think at least my friend would happily substitute pedigree
for another item on a person's resume that demonstrated experience with
running a live system where downtime is very costly.

------
kasey_junk
HFT and Trading firms are largely like any other firms. They have job postings
and the skillset they expect is largely what you’d expect.

[https://www.virtu.com/careers/](https://www.virtu.com/careers/) has a devops
role listed within the first 10 results on their careers page. It looks like
basically any other modern ops job sheet.

Here is one for DRW
[https://drw.com/careers/job/1280794](https://drw.com/careers/job/1280794)
again, not much different than any other firm.

Most software written at trading firms is the same as software written
anywhere else. The only real differences are on the actual tick to trade path,
where you will see the need for FPGA/ASIC programming, very low level network
programming and C/C++ systems programming or on the Quant side which can vary
widely but typically involves showing PHD level research skills in some hard
math/science.

------
morelandjs
Suppose you have top notch data science and machine learning chops and also
suppose quant shops are willing to hire you regardless of your financial
domain expertise.

In such a scenario, is the 99th percentile of quant compensation significantly
higher than the 99th percentile of tech company compensation (FANG etc)?

I've always considered this a fork in the road for many---finance versus say
advertising--and I'm curious how others with more experience would describe
the pros and cons of each.

~~~
ryanianian
I've done FAANG, and I have friends who've done the HFT shops.

HFT shops do indeed pay more. Perhaps at the top percentiles they're similar
but at the median, HFT probably pays double, and it's cash, not RSUs that vest
over many years. The downside: culture of always in the office (not sure how
covid will affect this), software that is insanely specialized and
uninspiring, and generally awful work/life balance. I'm sure some shops are
different, but they expect you to put in a lot of time to earn that salary.
Compared with FAANG where the burn-out is at little more prolonged (and of
course the morally dubious business that is ad-tech).

I've learned to stay away from both and have never looked back. But I think
working a FAANG or HFT is a good thing for any dev to at least look into while
they're young and ambitious and can "afford" a bit of burnout to see what life
can really be like (or not).

~~~
logicchains
Counterpoint: I've worked in two HFTs, and both have very decent hours and
work/life balance.

~~~
JAlexoid
Define "decent". Is it 80/60/50 hours per week? Because it's clearly not
regular 40 hour weeks.

Because I can work in a very chill environment and earn 200k-250k + stock. I
can also work 60 hour weeks for 300k + bonus.

I used to work in London on roughly $180k putting in about 20 hours per week.

~~~
wikibob
Where were you working? Or maybe you can say a list of similar places if you
don’t want to be specific

------
Jhsto
From the anecdotal experience of developing such software as a side-project
for myself, the hardest parts technically were dealing with concurrency and
race conditions caused by it. Other skills for prosperity is understanding
statistical significance and randomness. Also, writing reliable software and
designing both the best-case and worst-case scenarios is required when
interfacing with remote systems: brokers return error or exception cases
saying you were too slow all the time, which means your software is dependant
on that information and must run in probabilistic state conditions while
waiting for the answers to remain performant.

~~~
fareesh
When dealing with race-conditions, is the skill required just the ability to
identify candidates where the race-condition will occur and then apply the
relevant locking features around the mutations? What are the implications of
identifying a scenario where there is no race condition? Does it just result
in a performance hit?

~~~
Jhsto
In my case, I still have unexplainable race conditions in my software, so take
it with a grain of salt. But yes, identification and understanding both the
locking and synchronization are hard. I don't think there are many other
definitive solutions than modeling your software in a predicate language like
TLA+ or Alloy, especially once your software grows hence its possible states
diverge.

> What are the implications of identifying a scenario where there is no race
> condition?

No race condition? Great. It's totally possible there are some not-so-
concurrent parts of your software that can run in what I deem a performant
manner.

> Does it just result in a performance hit?

It's much more than that. A bug I have is very serious and it goes something
like this: you set a limit order to buy X shares. The limit order gets a
partial fulfillment, and you immediately set stop losses and take profits for
X shares. However, the limit order gets complete fulfillment before the two
other requests are done. If you now try to update the previous orders, for
example, it might be that the update call gets registered at the broker first,
but the creation gets there last, which means you have bought X+Y shares, but
you have stop losses and take profits for only the X. You might now completely
lose Y unless you monitor the software all the time. Things like these might
happen everywhere, and the real trouble starts when these instances with
plausible race conditions of their own start communicating with other parts
which might also have race conditions.

And the requirement for the concurrency is not only a performance: you might
want to collect data in thread N, while you have different strategies of
amount M, which all by default subscribe to N, but only selectively when they
are doing their strategies. In such a sense, I don't think that doing even a
semi-serious trading software without concurrency is possible.

~~~
gen220
What language are you writing it in? There are some common tools that can
detect race conditions dynamically (i.e. at runtime). Especially easy in a
language with a GC where you can lean on the reference counter.

Go for example has a race condition detector built in to the tool chain (go
run/test/build --race). They won’t tell you how to fix it, but they’ll tell
you which lines are in the critical region that the programmer missed.

~~~
Jhsto
I am indeed writing it in Go, but I have somehow missed the race condition
detector... So thanks for reminding me of it! Once I get back to programming
it more I'll look up how to properly make use of all the tooling -- the last
time I ran money on it I simply made a service which phoned me every time a
trade was happening, so I could observe _any_ bug in real-time.

~~~
gen220
Ah great! I hope the pointer saves you $5 :)

Go’s support for race detectors is super ergonomic. You need a unit test for
the parent function that’s spawning the routines. Run that unit test with the
race flag, and it’ll catch it for you. If you’re curious about how it works,
this post is good: [https://blog.golang.org/race-
detector](https://blog.golang.org/race-detector)

------
idohft
Agreed with the rest, you should just look at job descriptions. Different
firms use different technologies, but a devops person will probably be
building tooling for monitoring live trading, or GUIs for themselves and
traders. These tend to not be as performance-sensitive.

If you want to work on the trading systems, you should be good OS-level and
network-level things. And you should probably know C/C++. I think some firms
might still use Java.

Good firms have probably been around for a couple of years, so it's unlikely
that they'll use the cool new languages of the day.

~~~
xwdv
Cool new languages don’t provide any competitive advantage. You will not be
doing HFT with Rust or Haskell or whatever.

~~~
emidln
That's not true. Source: I work at an HFT. Rust is very interesting for
Greenfield work. The major down side is millions of lines of legacy C++, the
more useful already using C++17 or C++2a, which typically provides a lot of
what you'd get out of Rust's stdlib and ecosystem but already packaged and
integrated. When you choose Rust at an HFT you have to worry about integration
with codegen tools (generating efficient Java/C++/$HDL and reasonable
throughput Python for protocol definitions is table stakes at any HFT I've
heard of) and build pipelines (which might already have distributed
building/caching infrastructures and fancy packaging/deployment.

Rust has some benefits (and still integrates reasonably well at the ABI
level), but modern C++ compilers are no slouches. Rust provides a friendly dev
experience, which is a valuable thing, but a lot of the ecosystem advantages
are old hat at companies with mature codebases.

~~~
mraza007
I think Jane Street is using OCaml I’m not sure why did they decided to go
with functional programming even though most popular firms are still using
C/C++ Do you think using functional programming might have advantage over
these programming languages

Just curious to find out

~~~
emidln
Jane Street has some blog posts talking about why they chose OCaml.

I'm very torn on this. I've used Rust to quickly prototype things that I think
could be used I prod. It's fine. In some places it is better than what we had
for C++, in most places it is very similar for experienced devs. I don't think
Rust let me complete my code any quicker than if I had done it with standard
C++ tooling.

The main issue I see with something other than C++ is compiler maintenance.
gcc and clang generate very good code. There exists a good body of well
optimized C++ for various use cases (various kinds of latency and throughput).
It takes a lot of commitment to maintain and extend a compiler to keep it on
par with gcc/clang and also still maintain a good stdlib for trading.

I think a huge benefit of owning your compiler in a functional language would
be easier/better codegen, particularly the ability to sidestep some of the
shittier hardware languages with a better DSL (since you already have some
compiler and tooling expertise in-house). This matters at lot for HFT since at
the most critical places, you want to use FPGAs or better.

~~~
tluyben2
> you want to use FPGAs or better.

What are those used for? I only did slower signal trading bots and this sounds
interesting as I make hardware as well.

------
unixhero
Nobody has mentioned the K language and Q language; and the Kdb+ product from
KX Systems. I know many institutions and HFT's use the K Database. It's fast
because it crunches data in the CPU cache which is insanely fast.

Reference: [https://code.kx.com/](https://code.kx.com/)

~~~
throwfin11
kdb+ would be used for analysis or slower signal generation. it's not low
latency for trading applications.

------
_asummers
Trading firms have many positions available other than the HFT algorithms.
There are teams that support those to enable desks (read: startups) to get off
the ground quickly (like YC!), analysis teams for doing research for future
strategies, accounting, shared service teams, as well as governance teams like
risk, compliance, treasury. Depending on the team you're on, your job may be
drastically different. I find myself in a role focusing on devops, developer
tooling, and team automation, but others on my team focus on data ingestion,
financial models on top of the data, UI development for end users. If you're a
skilled programmer, there will be a role for you in a sufficiently large firm.

------
fwsgonzo
These days I would say you should get into OS development and learn about
unikernels. Linux should be a solved problem right now and the future would be
in OSes that don't have interrupts enabled and you have full control over the
CPU cores.

~~~
mraza007
I see I’m currently programming mostly in python at my day job do you any good
resources i could consume to gain more knowledge on OSes

~~~
fwsgonzo
This is not a joke: Read the Intel manual, maybe check out some of the
learning repos on github that solves all the glue-stuff that isn't important.
I have one such repo here:

[https://github.com/fwsGonzo/barebones](https://github.com/fwsGonzo/barebones)

~~~
mraza007
Thanks for sharing that Out of curiosity do you work for trading firms

------
andersonvaz
Worth to mention is the [https://lmax-
exchange.github.io/disruptor/](https://lmax-exchange.github.io/disruptor/)

A High Performance Inter-Thread Messaging Library used for HFT.

------
notinventedhear
From 4 years in a large public quant house (not HFT): everything upstream of
trade execution is Python with very heavy use of numpy, scipy and pandas. This
has pros and cons, on balance I'd prefer a better type system, but that
everyone in the org can share code has tremendous value at scale.

Briefly, the faster your execution the faster everything else needs to be.
Java should be fast enough for almost anything short of HFT + colocation which
is super expensive infra wise.

The skills are not different from other backend roles, but you will need to
exercise more math with emphasis time series and stats.

------
talolard
I used to work for a firm that did FIX parsers for hft. FIX is the standard
protocol for financial data. Company’s claim to fame was the fastest parser on
standard hardware as opposed to an FPGA and handling the many many dialects of
FIX.

A lot of work and skill went to memory layout (minimize cache missed), lock
free data structures and spending time in perf looking for ways to shave
microseconds off a function.

God knows how I got the job, I was super junior , but that’s the kind of work
we did and presumably what other companies would want you competent with

~~~
throwfin11
HFT firms would likely use the exchange binary protocols where available over
FIX. Ie: OUCH/ITCH, Pillar etc.

With that said, FIX is still relevant on many exchanges and in wide use by the
broker/dealers etc...

------
remyp
C/C++ is most common. Good luck getting their attention if you didn’t go to
MIT, CMU, Stanford, etc.

~~~
akhilcacharya
Citadel notably interviews people from all over. Chicago trading firms are
also more egalitarian, like Belvedere or Wolverine or DRW or Akuna.

Source - got an offer from Citadel previously without a top school or C/C++
expertise.

~~~
mraza007
Wait how come if you don’t mind sharing your experience

~~~
akhilcacharya
My interview loop was mostly UI related. All of these trading firms and hedge
funds require UI expertise at some form, either for WPF/QT apps or web UXs for
reactive charts, tables, etc.

~~~
mraza007
Wow that nices so It's easy land a postion with these expertise too but I
guess it hard to get your recognized in the first place

~~~
akhilcacharya
The loops were imho, pretty tough but focused on library specific knowledge
while implementing algorithms in the form of live coding.

------
pmart123
I used to work in HFT, but haven’t for five years. For core developers,
there’s heavy use of C/C++ with a deep understanding of low level programming.
On the trade strategy development side, it’s usually some combination of a
columnar database, Python/R along with rewriting performance sensitive areas
in a lower level language. I won’t be surprised if there was an uptick in the
usage of GO the last few years as well.

------
madballster
Not exactly known for HFT, but Man AHL use their own library arctic with
Python/Pandas and MongoDB. See
[https://www.youtube.com/watch?v=FVyIxdxsyok](https://www.youtube.com/watch?v=FVyIxdxsyok)
\- The presentation touches on performance considerations.

------
dilandau
C++ was big. Comfortable navigating a very large and complex codebase, being
able to understand complex rules-based systems, and of course knowledge of
equities and financial markets.

But they'll teach you everything you need to know as long as you can pass the
interview.

------
cheezebubba
Well you can take a look at their job openings pages:

[https://www.hudsonrivertrading.com/careers/](https://www.hudsonrivertrading.com/careers/)

Looks like c++, python, and linux sysadmin stuff.

~~~
mraza007
Do you work at HRT. just curious

------
andrew-nguyen
Besides searching on Glassdoor or Indeed, how can someone find a list of
companies that are doing this type of work? Are they limited to the east
coast?

I'm not very familiar with the HFT industry, but the skills that they require
(C++, computer architecture, OS, networking, & performance) are ones that I'm
interested in and would love to deepen my experience with. Are there companies
on the west coast (more specifically southern California) where one could
develop this experience?

~~~
mark-r
They'll probably be located close to an exchange so that they can colo the
servers, but not all exchanges are on the east coast.

------
Unklejoe
They usually ask for C/C++, but what they really mean is C++.

~~~
ryanianian
Not just "C++" but usually they want C++ experience that is very relevant to
precisely what the hiring manager wants.

Maybe I'm sour-grapes, but I got pretty far through a HFT loop only to get
turned away because I didn't have any experience with the particular boost
library they were using. (A library that will be mostly obsolete by C++20)
They said that this was common in the industry.

~~~
logicchains
>because I didn't have any experience with the particular boost library they
were using. (A library that will be mostly obsolete by C++20)

Brave of you to assume they'd be able to use C++20. Unfortunately HFTs are
just as susceptible to "stuck on an ancient version of GCC" as any other C++
shop, so maybe you dodged a bullet there.

------
throwfin11
HFT firms use all sorts of technologies. But to be clear, you want to be
closest to trading - that's where the big money is; so either a) idea
generation (quant work) or b) execution (dev work) For the execution piece,
C++ would be the most viable option.

On the quant/research piece, python/R/kdb are common tools used, but the real
skills are the statistics/math and market knowledge.

------
lalalal123
I worked at one of the top tier prop shops in Chicago. This is my experience
there:

Fresh grad devs are generally evaluated on their potential and not what
languages and specific skills they know. The people they end up hiring for
fresh grad dev roles tended to come from the same six schools. Said schools
are generally not top tier (for developers) and are local to Chicago.

~~~
mraza007
Compared to New York, I think you'll find out more trading jobs in Chicago.

------
necrotic_comp
DevOps - standard tools, depends on the firm

Trading Systems - C++, networking, memory management.

* I work at a HFT firm building algos for clients

~~~
mraza007
Nice building algo requires heavy math knowledge correct me if I’m wrong Most
firms look for masters or Phds for that type of role

~~~
logicchains
"Building algos for clients" may refer to implementing the algos designed by
traders/quants.

------
mattbl
Here's a nice (old) blog of someone in the industry: [https://mechanical-
sympathy.blogspot.com/](https://mechanical-sympathy.blogspot.com/)

------
franze
>How can a person excel at the technologies required by these firms from my
fintech experience with the financial departments there ... excel in Excel.
it's a whole programming-parallel-world

~~~
whatok
For HFT? Absolutely not. For trading? The original poster needs to clarify
what they mean by "trading" as this is probably still the case for most tech-
driven prop trading firms.

~~~
AllanHoustonSt
You’d be surprised at how many traders and QRs in HFT (or at least in OMM)
often reach for Excel. Granted this is way more common among older people in
the industry. And as a technologist OP wouldn’t have to worry about writing or
maintaining Excel scripts :p

~~~
whatok
Excel is a very effective tool for many things but suggesting that it would be
useful to spend time learning Excel to prepare for HFT is really bad advice.

------
szczepano
for currencies / commodities

zmq/java - lmax

then there is forex c++ mt4 metaquotes

more hardcore like cheetah-solutions fpga / hdl

don't know about asic

some insides but now inactive
[https://mdavey.wordpress.com/](https://mdavey.wordpress.com/)

there are also options / stocks and cryptocurrencies

