nach oben

Software Quality Journal

Erschienen in:

16.11.2018

To var or not to var: how do C# developers use and misuse implicit and explicit typing?

verfasst von: Pierre A. Akiki

Erschienen in: Software Quality Journal | Ausgabe 3/2019

Einloggen

Aktivieren Sie unsere intelligente Suche, um passende Fachinhalte oder Patente zu finden.

search-config

KI-gestützte Suche

Aus

Abstract

When implicit typing with the “var” keyword was introduced into C#, it prompted contradictory opinions among developers. This paper starts by explaining the difference between implicit and explicit typing and then provides an overview of developers’ opinions and guidelines that are available online. This paper then reports on the results of a study that investigated how C# developers use and misuse implicit and explicit typing. This study involved analyzing the source code of 10 different open-source software projects including more than 16,500,000 lines of code and more than 930,000 variables. This study investigated to what extent developers use a form of typing that affects the readability of a variable’s type and the length of its declaration. It also investigated whether or not there is an adoption of a consistent set of guidelines in general and across each software project. A tool called “Code Analysis and Refactoring Engine for C#” (Care#) was developed and used to conduct the code analysis for this study.

Vorheriger Artikel Risk factors in software development projects: a systematic literature review

Nächster Artikel Assisting software engineering students in analyzing their performance in software development

Sie haben noch keine Lizenz? Dann Informieren Sie sich jetzt über unsere Produkte:

Springer Professional "Wirtschaft"

Online-Abonnement

Mit Springer Professional "Wirtschaft" erhalten Sie Zugriff auf:

über 67.000 Bücher
über 340 Zeitschriften

aus folgenden Fachgebieten:

Bauwesen + Immobilien
Business IT + Informatik
Finance + Banking
Management + Führung
Marketing + Vertrieb
Versicherung + Risiko

Jetzt Wissensvorsprung sichern!

Jetzt informieren

Springer Professional "Wirtschaft+Technik"

Online-Abonnement

Mit Springer Professional "Wirtschaft+Technik" erhalten Sie Zugriff auf:

über 102.000 Bücher
über 537 Zeitschriften

aus folgenden Fachgebieten:

Automobil + Motoren
Bauwesen + Immobilien
Business IT + Informatik
Elektrotechnik + Elektronik
Energie + Nachhaltigkeit
Finance + Banking
Management + Führung
Marketing + Vertrieb
Maschinenbau + Werkstoffe
Versicherung + Risiko

Jetzt Wissensvorsprung sichern!

Jetzt informieren

Springer Professional "Technik"

Online-Abonnement

Mit Springer Professional "Technik" erhalten Sie Zugriff auf:

über 67.000 Bücher
über 390 Zeitschriften

aus folgenden Fachgebieten:

Automobil + Motoren
Bauwesen + Immobilien
Business IT + Informatik
Elektrotechnik + Elektronik
Energie + Nachhaltigkeit
Maschinenbau + Werkstoffe

Jetzt Wissensvorsprung sichern!

Jetzt informieren

Al Dallal, J., & Abdin, A. (2018). Empirical evaluation of the impact of object-oriented code refactoring on quality attributes: a systematic literature review. IEEE Transactions on Software Engineering, 44(1), 44–69.CrossRef

Albahari, J., & Albahari, B. (2016). C# 6.0 in a nutshell. Oreilly.

Binkley, D. (2007). Source code analysis: a road map. in: Future of software engineering, 2007. FOSE’07. IEEE, pp. 104–119.

Butler, S., Wermelinger, M., Yu, Y., & Sharp, H. (2010). Exploring the influence of identifier names on code quality: an empirical study. In Software maintenance and reengineering (CSMR), 2010 14th European Conference On. IEEE, pp. 156–165.

Butler, S., Wermelinger, M., & Yu, Y. (2015). Investigating naming convention adherence in Java references. In Software maintenance and evolution (ICSME), 2015 IEEE International Conference On. IEEE, pp. 41–50.

Cabral, B., & Marques, P. (2007). Exception handling: a field study in Java and NET. In: E. Ernst, (Ed.), ECOOP 2007—object-oriented programming: 21st European conference, Berlin, Germany, July 30–august 3, 2007. Proceedings. Springer: Berlin, pp. 151–175. https://doi.org/10.1007/978-3-540-73589-2_8.

Cacho, N., Barbosa, E. A., Araujo, J., Pranto, F., Garcia, A., Cesar, T., Soares, E., Cassio, A., Filipe, T., & Garcia, I. (2014a). How does exception handling behavior evolve? An exploratory study in Java and C# applications, in: Software maintenance and evolution (ICSME), 2014 IEEE International Conference On. IEEE, pp. 31–40.

Cacho, N., César, T., Filipe, T., Soares, E., Cassio, A., Souza, R., Garcia, I., Barbosa, E. A., & Garcia, A. (2014b). Trading robustness for maintainability: an empirical study of evolving C# programs, in: Proceedings of the 36th International Conference on Software Engineering, ICSE 2014. ACM: New York, pp. 584–595. https://doi.org/10.1145/2568225.2568308.

Callaú, O., Robbes, R., Tanter, É., & Röthlisberger, D. (2013). How (and why) developers use the dynamic features of programming languages: the case of small talk. Empirical Software Engineering, 18(6), 1156–1194. https://doi.org/10.1007/s10664-012-9203-2.CrossRef

Capek, P., Král, E., & Senkerik, R. (2015). Towards an empirical analysis of .NET framework and C# language features’ adoption. In Computational science and computational intelligence (CSCI), 2015 international conference on. IEEE, pp. 865–866.

Channel9. (2010). How much do you use “var” in C#? [WWW document]. URL https://channel9.msdn.com/Forums/Coffeehouse/How-much-do-you-use-var-in-C. Accessed 1.12.17.

Coleman, D., Ash, D., Lowther, B., & Oman, P. (1994). Using metrics to evaluate software system maintainability. IEEE Comput, 27(8), 44–49.CrossRef

Deissenboeck, F., & Pizka, M. (2006). Concise and consistent naming. Software Quality Journal, 14(3), 261–282.CrossRef

Deitel, P., & Deitel, H. (2018). Visual C# how to program (6th ed.). Pearson.

Fowler, M. (1999). Refactoring: improving the design of existing code. Addison-Wesley.

Ge, X., DuBose, Q. L., & Murphy-Hill, E. (2012). Reconciling manual and automatic refactoring. In Proceedings of the 34th international conference on software engineering. IEEE Press, pp. 211–221.

Ghosh, S., & Rana, A. K. (2011). Comparative study of the factors that affect maintainability. International Journal on Computer Science and Engineering, 3, 3763.

Griswold, W. G. (1991). Program restructuring as an aid to software maintenance. University of Washington.

Griswold, W. G., & Notkin, D. (1993). Automated assistance for program restructuring. ACM Transactions on Software Engineering and Methodology, 2(3), 228–269. https://doi.org/10.1145/152388.152389.CrossRef

Hashim, K. (1996). A software maintainability attributes model. Malaysian Journal of Computer Science, 9, 92–97.

Hejlsberg, A. (2008). Anders Hejlsberg talks about the C# Language [WWW Document]. URL https://www.youtube.com/watch?v=dc-YDS4JVA8. Accessed 11.12.17.

IC#Code. (2016). SharpDevelop [WWW document]. URL http://www.icsharpcode.net/OpenSource/SD/Default.aspx. Accessed 10.23.17.

JetBrains. (2018a). ReSharper [WWW document]. URL https://www.jetbrains.com/resharper. Accessed 1.3.08.

JetBrains. (2018b). ReSharper “var” keyword [WWW document]. URL https://www.jetbrains.com/help/resharper/Using_var_Keyword_in_Declarations.html#preferences. Accessed 1.3.18.

Kim, D., Murphy-Hill, E. R., Parnin, C., Bird, C., & Garcia, R. (2013). The reaction of open-source projects to new language features: an empirical study of C# generics. Journal of Object Technology, 12, 1–1.CrossRef

Lawrie, D., Feild, H., & Binkley, D. (2007). Quantifying identifier quality: an analysis of trends. Empirical Software Engineering, 12(4), 359–388.CrossRef

Lientz, B. P., & Swanson, E. B. (1980). Software maintenance management: a study of the maintenance of computer application software in 487 data processing organizations. Addison-Wesley.

Lippert, E. (2011). Uses and misuses of implicit typing [WWW Document]. URL https://blogs.msdn.microsoft.com/ericlippert/2011/04/20/uses-and-misuses-of-implicit-typing. Accessed 4.20.11.

Ma, L., Zhang, C., Yu, B., & Sato, H. (2017). An empirical study on the effects of code visibility on program testability. Software Quality Journal, 25(3), 951–978. https://doi.org/10.1007/s11219-016-9340-8.CrossRef

Marcus, A., & Maletic, J. I. (2001). Identification of high-level concept clones in source code, in: Automated software engineering, 2001.(ASE 2001). Proceedings. 16th annual international conference on. IEEE, pp. 107–114.

Martin, R. C. (2009). Clean code: a handbook of agile software craftsmanship. Pearson Education.

Mens, T., et al. (2004). A survey of software refactoring. IEEE Transactions on Software Engineering, 30(2), 126–139.CrossRef

Microsoft. (2015a). C# coding conventions (C# programming guide) [WWW document]. URL https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/inside-a-program/coding-conventions. Accessed 11.30.17.

Microsoft. (2015b). Var (C# reference) [WWW document]. URL https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/var. Accessed 11.30.17.

Microsoft. (2015c). Implicitly typed local variables (C# programming guide) [WWW document]. URL https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/implicitly-typed-local-variables. Accessed 11.30.17.

Microsoft. (2017a). Net core [WWW Document]. URL https://www.microsoft.com/net/core. Accessed 10.23.17.

Microsoft. (2017b). Roslyn [WWW document]. URL https://roslyn.codeplex.com. Accessed 10.23.17.

MixERP Inc. (2015). MixERP [WWW Document]. URL https://mixerp.org. Accessed 10.23.17.

MonoDevelop Project. (2017). MonoDevelop [WWW Document]. URL www.monodevelop.com. Accessed 10.23.17.

Murphy-Hill, E., & Black, A. P. (2008). Refactoring tools: fitness for purpose. IEEE Software, 25(5), 38–44.CrossRef

NHibernate Community. (2017). NHibernate [WWW Document]. URL http://nhibernate.info. Accessed 10.23.17.

Okur, S., & Dig, D. (2012). How do developers use parallel libraries? In Proceedings of the ACM SIGSOFT 20th international symposium on the foundations of software engineering, FSE ‘12. ACM, New York, NY, USA, pp. 54:1–54:11. https://doi.org/10.1145/2393596.2393660.

Okur, S., Hartveld, D. L., Dig, D., van Deursen, A. (2014). A study and toolkit for asynchronous programming in C#. In Proceedings of the 36th international conference on software engineering. ACM, pp. 1117–1127.

Oliveira, J., Borges, D., Silva, T., Cacho, N., & Castor, F. (2018). Do android developers neglect error handling? A maintenance-centric study on the relationship between android abstractions and uncaught exceptions. Journal of Systems and Software, 136, 1–18.CrossRef

Opdyke, W. F. (1992). Refactoring: a program restructuring aid in designing object-oriented application frameworks. University of Illinois at Urbana-Champaign.

OpenRA. (2017). [WWW Document]. URL http://www.openra.net. Accessed 10.23.17.

Parr, T. (2018). ANTLR [WWW Document]. URL http://www.antlr.org. Accessed 4.1.18.

Peercy, D. E. (1981). A software maintainability evaluation methodology. IEEE Transactions on Software Engineering, SE-7(4), 343–351.CrossRef

Poole, C., Prouse, R., Busoli, S., & Colvin, N. (2017). NUnit [WWW Document]. URL http://nunit.org. Accessed 10.23.17.

Shadowsocks Community. (2017). Shadowsocks [WWW Document]. URL https://shadowsocks.org. Accessed 10.23.17.

ShareX Team. (2017). ShareX [WWW Document]. URL https://getsharex.com. Accessed 10.23.17.

Shore J. (2004). Design debt. Software Profitability.

Soares, G., Gheyi, R., Serey, D., & Massoni, T. (2010). Making program refactoring safer. IEEE Software, 27(4), 52–57.CrossRef

Szoke, G., Nagy, C., Fülöp, L. J., Ferenc, R., & Gyimóthy, T. (2015). FaultBuster: an automatic code smell refactoring toolset, in: Source code analysis and manipulation (SCAM), 2015 IEEE 15th international working conference on. IEEE, pp. 253–258.

TIOBE. (2017). TIOBE programming community index [WWW document]. URL https://www.tiobe.com/tiobe-index. Accessed 12.26.17.

Various. (2014). Debate on typing: unity forum [WWW document]. URL https://forum.unity.com/threads/c-microsoft-suggests-using-var-instead-of-a-type.232732/. Accessed 11.30.17.

Vidal, S. A., Marcos, C., & Díaz-Pace, J. A. (2016). An approach to prioritize code smells for refactoring. Automated Software Engineering, 23(3), 501–532.CrossRef

Titel: To var or not to var: how do C# developers use and misuse implicit and explicit typing?
verfasst von: Pierre A. Akiki
Publikationsdatum: 16.11.2018
Verlag: Springer US
Erschienen in: Software Quality Journal / Ausgabe 3/2019
Print ISSN: 0963-9314
Elektronische ISSN: 1573-1367
DOI: https://doi.org/10.1007/s11219-018-9426-6

Springer Professional

Abstract

Bitte loggen Sie sich ein, um Zugang zu Ihrer Lizenz zu erhalten.

Sie haben noch keine Lizenz? Dann Informieren Sie sich jetzt über unsere Produkte:

Springer Professional "Wirtschaft"

Springer Professional "Wirtschaft+Technik"

Springer Professional "Technik"

Weitere Artikel der Ausgabe 3/2019

Classifying generated white-box tests: an exploratory study

A new weighted naive Bayes method based on information diffusion for software defect prediction

Special issue on trustworthy systems and software

API trustworthiness: an ontological approach for software library adoption

A large-scale empirical study of code smells in JavaScript projects

Assisting software engineering students in analyzing their performance in software development