Asynchronous Byzantine Consensus. - Chagit Attiya; Danny Dolev; Joseph Gil (PODC, 1984)

Counting and Packing in Parallel. - Joseph Gil; Larry Rudolph (ICPP, 1986)

Not All Keys Can Be Hashed in Constant Time (Preliminary Version) - Joseph Gil; Friedhelm Meyer auf der Heide; Avi Wigderson (STOC, 1990)

Lower bounds and algorithms for hashing and parallel processing (חסמים תחתונים ואלגוריתמים בערבול ובחשוב מקבילי.). - Joseph Gil (1990)

Towards a Theory of Nearly Constant Time Parallel Algorithms - Joseph Gil; Yossi Matias; Uzi Vishkin (FOCS, 1991)

Fast Hashing on a PRAM - Designing by Expectation. - Joseph Gil; Yossi Matias (SODA, 1991)

Fast load balancing on a PRAM. - Joseph Gil (SPDP, 1991)

Polynomial Hash Functions Are Reliable (Extended Abstract). - Martin Dietzfelbinger; Joseph Gil; Yossi Matias; Nicholas Pippenger (ICALP, 1992)

Leaders Election Without Conflict Resolution Rule - Fast and Efficient Randomized Simulations among CRCW PRAMs. - Joseph Gil; Yossi Matias (LATIN, 1992)

Geometric medians. - Joseph Gil; William L. Steiger; Avi Wigderson (Discret. Math., 1992)

Computing 2-D Min, Median, and Max Filters. - Joseph Gil; Michael Werman (IEEE Trans. Pattern Anal. Mach. Intell., 1993)

Simple Fast Parallel Hashing. - Joseph Gil; Yossi Matias (ICALP, 1994)

Designing Algorithms by Expectations. - Joseph Gil; Yossi Matias (Inf. Process. Lett., 1994)

Renaming and dispersing: Techniques for Fast Load Balancing. - Joseph Gil (J. Parallel Distributed Comput., 1994)

Fast and Efficient Simulations among CRCW PRAMs. - Joseph Gil; Yossi Matias (J. Parallel Distributed Comput., 1994)

Packing Trees. - Joseph Gil; Alon Itai (ESA, 1995)

Linear Time Euclidean Distance Algorithms. - Heinz Breu; Joseph Gil; David G. Kirkpatrick; Michael Werman (IEEE Trans. Pattern Anal. Mach. Intell., 1995)

A New Technique for 3-D Domain Decomposition on Multicomputers which Reduces Message-Passing. - Joseph Gil; Alan S. Wagner (IPPS, 1996)

Environmental Acquisition - A New Inheritance-Like Abstraction Mechanism. - Joseph Gil; David H. Lorenz (OOPSLA, 1996)

An Effective Load Balancing Policy for Geometric-Decaying Algorithms. - Joseph Gil; Yossi Matias (J. Parallel Distributed Comput., 1996)

The Tree Model for Hashing: Lower and Upper Bounds. - Joseph Gil; Friedhelm Meyer auf der Heide; Avi Wigderson (SIAM J. Comput., 1996)

Design Patterns vs. Language Design. - Joseph Gil; David H. Lorenz (ECOOP Workshops, 1997)

Precise Specification and Automatic Application of Design Patterns. - Amnon H. Eden; Amiram Yehudai; Joseph Gil (ASE, 1997)

Keynotes. - James Coplien; Joseph Gil; David Harel; Bertrand Meyer 001 (TOOLS (23), 1997)

Extendability vs. Substitutability in OO Languages. - Yossi Gil (TOOLS (25), 1997)

T++: A Test Case Generator Using a Debugging Information Based Technique for Source Code Manipulation. - Joseph Gil; Beery Holstein (TOOLS (23), 1997)

Automating the Application of Design Patterns. - Amnon H. Eden; Joseph Gil; Amiram Yehudai (J. Object Oriented Program., 1997)

Compile Time Symbolic Derivation with C++ Templates. - Joseph Gil; Zvi Gutterman (COOTS, 1998)

The Complexity of Type Analysis of Object Oriented Programs. - Joseph Gil; Alon Itai (ECOOP, 1998)

Three Dimensional Software Modeling. - Joseph Gil; Stuart Kent 001 (ICSE, 1998)

Statically Checkable Design Level Traits. - Joseph Gil; Y. Eckel (ASE, 1998)

Design Patterns and Language Design. - Joseph Gil; David H. Lorenz (Computer, 1998)

Visualising action contracts in object-oriented modelling. - Stuart Kent 001; Joseph Gil (IEE Proc. Softw., 1998)

Simple Fast Parallel Hashing by Oblivious Execution. - Joseph Gil; Yossi Matias (SIAM J. Comput., 1998)

Aspects and Superimpositions. - Shmuel Katz; Joseph Gil (ECOOP Workshops, 1999)

Space and Time-Efficient Memory Layout for Multiple Inheritance. - Peter F. Sweeney; Joseph Gil (OOPSLA, 1999)

Constraint Diagrams: A Step Beyond UML. - Joseph Gil; John Howse; Stuart Kent 001 (TOOLS (30), 1999)

Formalizing Spider Diagrams. - Joseph Gil; John Howse; Stuart Kent 001 (VL, 1999)

How to Pack Trees. - Joseph Gil; Alon Itai (J. Algorithms, 1999)

An Alternative Mapping of 3-D Space onto Processor Arrays. - Joseph Gil; Alan S. Wagner (J. Parallel Distributed Comput., 1999)

Empirical Study of Object-Layout Strategies and Optimization Techniques. - Natalie Eckel; Joseph Gil (ECOOP, 2000)

Advanced visual modeling (tutorial session): beyond UML. - Joseph Gil; John Howse; Stuart Kent 001 (ICSE, 2000)

Self-Calibration of Metrics of Java Methods. - Tal Cohen; Joseph Gil (TOOLS (37), 2000)

Advanced Visual Modeling: Beyond UML. - Joseph Gil; John Howse; Stuart Kent 001 (TOOLS (33), 2000)

Projections in Venn-Euler Diagrams. - Joseph Gil; John Howse; Stuart Kent 001; John Taylor 001 (VL, 2000)

Sealing, Encapsulation, and Mutability. - Marina Biberstein; Joseph Gil; Sara Porat (ECOOP, 2001)

Subtyping arithmetical types. - Joseph Gil (POPL, 2001)

Towards a Formalization of Constraint Diagrams. - Joseph Gil; John Howse; Stuart Kent 001 (HCC, 2001)

Spider Diagrams: A Diagrammatic Reasoning System. - John Howse; Fernando Molina; John Taylor 001; Stuart Kent 001; Joseph Gil (J. Vis. Lang. Comput., 2001)

Advanced visual modelling: beyond UML. - Joseph Gil; John Howse; Stuart Kent 001 (ICSE, 2002)

Fast algorithm for creating space efficient dispatching tables with application to multi-dispatching. - Yoav Zibin; Joseph Gil (OOPSLA, 2002)

Efficient Dilation, Erosion, Opening, and Closing Algorithms. - Joseph Gil; Ron Kimmel (IEEE Trans. Pattern Anal. Mach. Intell., 2002)

Positive Semantics of Projections in Venn-Euler Diagrams. - Joseph Gil; John Howse; Elena Tulchinsky (J. Vis. Lang. Comput., 2002)

Two-Dimensional Bi-directional Object Layout. - Yoav Zibin; Joseph Gil (ECOOP, 2003)

Visualizing class interfaces with formal concept analysis. - Uri Dekel; Joseph Gil (OOPSLA Companion, 2003)

Incremental algorithms for dispatching in dynamically typed languages. - Yoav Zibin; Joseph Gil (POPL, 2003)

Efficient algorithms for isomorphisms of simple types. - Yoav Zibin; Joseph Gil; Jeffrey Considine (POPL, 2003)

Revealing Class Structure with Concept Lattices. - Uri Dekel; Yossi Gil (WCRE, 2003)

Automated Transformations for PDE Systems with Application to Multigrid Solvers. - Yossi Gil; Zvi Gutterman; Shmuel Onn; Irad Yavneh (SIAM J. Sci. Comput., 2003)

AspectJ2EE = AOP + J2EE. - Tal Cohen; Joseph Gil (ECOOP, 2004)

Type-safe covariance in C++. - Vitaly Surazhsky; Joseph Gil (SAC, 2004)

Micro patterns in Java code. - Joseph Gil; Itay Maman (OOPSLA, 2005)

Efficient algorithms for isomorphisms of simple types. - Joseph Gil; Yoav Zibin (Math. Struct. Comput. Sci., 2005)

Efficient subtyping tests with PQ-encoding. - Joseph Gil; Yoav Zibin (ACM Trans. Program. Lang. Syst., 2005)

Software Fingerprinting. - Joseph Gil; Alexander Gorovoy; Alon Itai (ITRE, 2006)

JTL: the Java tools language. - Tal Cohen; Joseph Gil; Itay Maman (OOPSLA, 2006)

Shakeins: Nonintrusive Aspects for Middleware Frameworks. - Tal Cohen; Joseph Gil (LNCS Trans. Aspect Oriented Softw. Dev., 2006)

Datalog Programs over Infinite Databases, Revisited. - Sara Cohen; Joseph Gil; Evelina Zarivach (DBPL, 2007)

Eliminating Impedance Mismatch in C++. - Joseph Gil; Keren Lenz (VLDB, 2007)

Better Construction with Factories. - Tal Cohen; Joseph Gil (J. Object Technol., 2007)

Randomised algorithms for isomorphisms of simple types. - Joseph Gil; Yoav Zibin (Math. Struct. Comput. Sci., 2007)

Efficient dynamic dispatching with type slicing. - Joseph Gil; Yoav Zibin (ACM Trans. Program. Lang. Syst., 2007)

Whiteoak: introducing structural typing into java. - Joseph Gil; Itay Maman (OOPSLA, 2008)

Guarded Program Transformations Using JTL. - Tal Cohen; Joseph Gil; Itay Maman (TOOLS (46), 2008)

Two-dimensional bidirectional object layout. - Joseph Gil; William W. Pugh; Grant E. Weddell; Yoav Zibin (ACM Trans. Program. Lang. Syst., 2008)

Are We Ready for a Safer Construction Environment? - Joseph Gil; Tali Shragai (ECOOP, 2009)

Three approaches to object evolution. - Tal Cohen; Joseph Gil (PPPJ, 2009)

The Use of Overloading in Java Programs. - Joseph Gil; Keren Lenz (ECOOP, 2010)

Reflections on Spartan Programming and the No-Debugger Principle. - Joseph Gil (Haifa Verification Conference, 2010)

Sans Constraints? Feature Diagrams vs. Feature Models. - Yossi Gil; Shiri Kremer-Davidson; Itay Maman (SPLC, 2010)

Simple and safe SQL queries with C++ templates. - Joseph Gil; Keren Lenz (Sci. Comput. Program., 2010)

How much information do software metrics contain? - Yossi Gil; Maayan Goldstein; Dany Moshkovich (PLATEAU, 2011)

A microbenchmark case study and lessons learned. - Joseph Gil; Keren Lenz; Yuval Shimron (SPLASH Workshops, 2011)

Smaller footprint for Java collections. - Joseph Gil; Yuval Shimron (OOPSLA Companion, 2011)

An empirical investigation of changes in some software properties over time. - Joseph Gil; Maayan Goldstein; Dany Moshkovich (MSR, 2012)

A Bijective String Sorting Transform - Joseph Yossi Gil; David Allen Scott (CoRR, 2012)

Empirical Confirmation (and Refutation) of Presumptions on Software - Joseph Gil; Maayan Goldstein; Dany Moshkovich (CoRR, 2012)

Keyword- and Default- Parameters in JAVA. - Joseph Gil; Keren Lenz (J. Object Technol., 2012)

On Incomplete Bug Fixes in Eclipse and Programmers' Intuition on These. - Sabih Agbaria; Joseph Gil (ACM SIGSOFT Softw. Eng. Notes, 2015)

Formal Language Recognition with the Java Type Checker. - Yossi Gil; Tomer Levy (ECOOP, 2016)

Structured gotos are (Slightly) harmful. - Eli Sennesh; Yossi Gil (SAC, 2016)

When do Software Complexity Metrics Mean Nothing? - When Examined out of Context. - Joseph Yossi Gil; Gal Lalouche (J. Object Technol., 2016)

Code Spartanization: one rational approach for resolving religious style wars. - Yossi Gil; Matteo Orrù (SAC, 2017)

Syntactic Zoom-Out / Zoom-In Code with the Athenizer. - Yossi Gil; Dor Ma'ayan; Niv Shalmon; Raviv Rachmiel; Ori Roth (VISSOFT, 2017)

Pluggable Controllers and Nano-Patterns. - Yossi Gil; Ori Marcovitch; Matteo Orrù (SANER, 2017)

The Spartanizer: Massive automatic refactoring. - Yossi Gil; Matteo Orrù (SANER, 2017)

Fitting long-tailed distribution to empirical data. - Joseph Yossi Gil; Cristina Monni (Concurr. Comput. Pract. Exp., 2017)

On the correlation between size and metric validity. - Yossi Gil; Gal Lalouche (Empir. Softw. Eng., 2017)

Fling - A Fluent API Generator. - Yossi Gil; Ori Roth (ECOOP, 2019)

Fling - A Fluent API Generator (Artifact). - Ori Roth; Yossi Gil (Dagstuhl Artifacts Ser., 2019)

A Nano-Pattern Language for Java. - Yossi Gil; Ori Marcovitch; Matteo Orrù (J. Comput. Lang., 2019)

Ties between Parametrically Polymorphic Type Systems and Finite Control Automata. - Joseph Gil; Ori Roth (CoRR, 2020)

Fluent APIs in Functional Languages (full version). - Ori Roth; Yossi Gil (CoRR, 2022)

Fluent APIs in Functional Languages. - Ori Roth; Yossi Gil (Proc. ACM Program. Lang., 2023)