We source, vet, and manage hiring so you can meet qualified candidates in days, not months. Strong English, U.S. time zone overlap, and compliant hiring built in.
.svg){kind=logo}
Self is a purely object-oriented, prototype-based programming language developed at Stanford in the 1980s. Unlike class-based languages (Java, Python, C++), Self uses prototypes as the fundamental unit of code reuse. Every object is a clone of an existing object, modified as needed. This approach directly influenced JavaScript's prototype inheritance model.
Self pioneered key concepts in object-oriented design: direct manipulation of objects through an integrated development environment, reflective capabilities for introspection and modification, and slots (methods and data combined as properties). The language was designed around the principle that everything is an object and that programmers should be able to inspect and modify any object at runtime.
Self is rarely used in production systems today, making it a specialized niche. Companies using Self typically maintain legacy systems built in the 1990s or are researching advanced meta-programming concepts. The language is valuable primarily in academic contexts and for engineers studying the history and theory of object-oriented programming.
Self hiring is rare in practice. Only maintain or extend legacy Self systems if you have existing code written in Self. Building new systems in Self is impractical due to the tiny ecosystem and near-zero adoption in industry.
If you have a historical Self codebase that needs maintenance or feature development, hire a Self specialist. These engineers are typically architects or senior researchers who understand both the language deeply and the theoretical foundations of object-oriented programming.
Self expertise is valuable in educational and research contexts. Universities teaching advanced programming language concepts may hire Self specialists to teach or research prototype-based systems. Research projects exploring meta-programming or reflective systems may benefit from Self knowledge.
Look for deep understanding of meta-programming, object-oriented theory, and the specific design of Self's object model. A good Self hire should be able to explain how slots work, how Self implements method dispatch, how the development environment enables live object manipulation, and how Self influenced JavaScript.
Mid-level (3-5 years): Writes solid Self code, understands the development environment, can diagnose and fix issues, understands the theoretical foundations of prototype-based OOP.
Senior (5+ years): Deep expertise in Self's design and implementation. Can architect complex systems using meta-programming capabilities. Understands how Self influenced other languages. Can mentor and explain subtle aspects of the language.
Tell me about the last Self system you worked on. Look for concrete examples and depth of engagement. If they've truly worked with Self, they should have real project experience to discuss.
How do you approach learning about a language or technology with very limited resources or community? This is relevant for Self work. Strong answers show resourcefulness, ability to read source code, and comfort learning through experimentation.
Explain what you understand about prototype-based inheritance and how it differs from class-based inheritance. This tests theoretical understanding. They should articulate why prototypes are different, the implications for code reuse, and how Self implements it.
What do you see as the lasting influence of Self on modern programming? Tests depth of knowledge. Strong answers mention JavaScript prototypes, meta-programming capabilities, and design principles that influenced other languages.
Explain how Self's object model works. What are slots, how does method dispatch work, and how does it compare to classes? This is fundamental. Look for understanding of how objects contain both methods and data, how slots work, how Self handles inheritance through delegation.
Write a simple Self program that demonstrates prototype-based inheritance and object creation. Look for understanding of how to clone objects, modify slots, and demonstrate that inheritance happens through object relationships, not class definitions.
How would you introspect an object in Self to discover what methods it responds to? Tests knowledge of Self's reflective capabilities. Look for understanding of the development environment and how to inspect runtime object structure.
Compare how polymorphism works in Self versus a class-based language like Java. Tests theoretical understanding of object-oriented design and how different inheritance models affect polymorphic behavior.
Specialized LatAm Rates (Extremely Rare):
Self expertise is so rare in Latin America that finding qualified specialists is extremely difficult. You may need to hire North American or European specialists instead.
Finding Self developers anywhere is difficult. Latin America has very few Self specialists due to the language's academic focus and lack of commercial adoption. If you need Self expertise, you're more likely to find it among computer science researchers or academics in Latin America than in the commercial technology sector.
However, Latin American universities with strong computer science programs may have researchers studying historical programming languages and object-oriented theory.
Matching Self specialists is extremely specialized. If you have a Self system requiring maintenance or development, South can help connect you with rare Self experts, though most will be located in North America or Europe rather than Latin America.
The matching process starts with understanding your specific Self requirements. We then search our network and broader engineering communities for specialists with Self experience. Given the rarity of Self expertise, you may need to consider hiring arrangement options like contract work or part-time advisory roles. Start at https://www.hireinsouth.com/start.
Self is used primarily in historical systems and academic research. It's rarely used in production technology stacks. If you have a Self system, it's likely legacy code built in the 1990s or academic research code.
No. Self is not suitable for new production systems. If you need prototype-based object-oriented design, use JavaScript or Lua. If you need meta-programming, use Python or Ruby.
JavaScript borrowed prototype-based inheritance from Self but simplified it significantly. JavaScript is much more practical for production use. Self is valuable for understanding the theory of prototype-based OOP, while JavaScript is what you use to build systems.
Self specialists are extremely rare, making rates highly variable. Expect to pay a premium for this specialized expertise. Rates likely range from $80,000-$200,000+ annually, depending on seniority and availability.
Given extreme scarcity, 3-8 weeks is realistic. South will search our network extensively, but finding qualified candidates requires patience. You may need to expand your search beyond Latin America.
Yes. Given the rarity of Self work, part-time or contract arrangements are common. You may find someone to dedicate 20-30% of their time to your Self system.
