DOCSLIB.ORG

Your First Function

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Your First Function California State University, Sacramento College of Engineering and Computer Science and Snarky Professors Computer Science 10517: Super Mega Crazy Accelerated Intro to Programming Logic Spring 2016 – Activity I – Functions Functions are a key part to any programming language. They differ from modules (as the textbook calls them) in that they can return a value. You have used this quite a bit during your time as a student. You should recall the Sin(x) and Cos(x) functions from trigonometry, the int(x) function from basic math, and sqrt(x) for those times you can't draw that funky square root line. Programming languages often let you create your own. And, in this lab, that is exactly what you are going to do! Part 1 – Your First Function In many programming languages the term "module" and "function" are one and the same. The only difference is that a function returns something while a module does not. NOTE: Redundant Terminology Programming languages often use different terms to describe the same concept. In the C Family (which includes Java), modules and functions are synonymous. Pascal calls a module a "procedure". Visual Basic calls it a "sub" (for subroutine). Whatever you call it…. programming languages let you create your own functions. They are defined pretty much the same way you create a module. To get started with functions, let's create a function that adds two numbers together and returns the result. 1. Start by selecting "Add a Function" from the Program Menu or clicking on the add icon on the main toolbar. 2. A new window will open. In the Function Name field, enter Sum. 3. Add two parameters to your function. Call them num1 and num2. Make both of them Integer. They will represent the two numbers the caller will pass in. 4. For the "Return Type", select "Integer". The "Return Variable" box is now enabled. 5. Enter the variable name result. This will be a variable that you have to declare inside your function. Don't use the same name as the function. Flowgorithm will throw a temper tantrum if you do. 2 NOTE: Returning Values in Flowgorithm Many programming languages can return the result of an expression. This can be a single variable (which is a very simple expression) or something far more complex. Flowgorithm just lets you return the contents of a variable. 6. Click OK 7. You should see a blank flowchart now with the word “sum” in the top bubble. Make it look like flowchart below. Notice that we declare an integer called result. This is the variable we will return to the caller. 8. Go back to your main function (click on the dropdown box on the toolbar) 9. Add an output shape. 10. In this output shape, type Sum(2, 2). 11. Execute your flowchart This makes it far more versatile than our earlier module which always just printed the sum. Excellent! Your flowchart uses a function to add two numbers and return the sum. However, this really isn't that useful. It's a useful start, but not still useful. So, let's work on something a bit more impressive! 3 Part 2 – Composition One of the great benefits of functions is the ability to use the output of one function as the input to another. In great languages, like Java, you can create sophisticated mathematical expressions that make use of operators such as: +, -, *, / In reality, these are functions, but they're in a nice easy-to-read format. So, for example, anytime you use the result of a multiplication, and add it to another number, you are using the output of one function as input into another. Let's try that out using your excellent sum function. 1. Double-click on output shape in your main module. 2. Change the expression to: Sum(2, Sum(2, 2)) Look at it really closely. Look at the first Sum in the expression. The first argument is the value 2. That's easy to understand. However, look at the second argument. That argument is the result of calling Sum with 2 and 2. What's the result? 3. Execute your flowchart. Did it output what you expected? Very cool! Let's see if we can get different values. 4. Add a new output shape 5. Double-click on it. 6. Figure out an expression that will print 10 to the screen. …but ONLY uses combinations of 2 and calls to Sum. 7. Execute your flowchart. If you didn't get 10, double-check your expression. Let's save your wonderful expression for later (we don't want to lose all that hard work). 8. Create another function – call it CompositionExample. 9. Go back to your main function 10. Cut your two output shapes. You should now have nothing in your main module. 11. Paste the output shapes into the function you just created. 4 Part 3 – Geometry Let's take a look at a sphere. If you forgot, the volume of a sphere can be computed with the following mathematical expression: 4 Diameter Volume = π × 3 3 ( 2 ) This equation uses Diameter/2 as a substitution for Radius. 1. Add a new function called sphereVolume 2. Add a parameter for the diameter. Make it a real. 3. Calculate the volume of a sphere, and return that value. Recall that Flowgorithm has π built-in as a constant called pi. Ah, now that you have written such a nice function, it is time to check if it works correctly. Look at the following pseudocode (written in the book's format). Example Pseudocode Module main Declare Real d Input d Display sphereVolume(d) End Module This program declares a real variable called d, inputs it, and then displays the result of the function. This is a great technique for testing if you got the expression correct. 4. You main function should be blank. Implement the pseudocode above. 5. Execute it your flowchart and test it with a few values. 6. Check your results with the table below Diameter Volume 1 0.523598833333332 2 4.18879066666666 10 523.598833333332 15 1767.1460625 20 4188.79066666666 Did everything match up? If so…. great work! It's time to move on. Otherwise, go back to your sphere function and double-check the expression. 5 Part 4 – Flowcharts and the Chocolate Factory You have a really cool job at a candy factory. The factory can make custom candies for anyone in the World. You work in the division that creates chocolate-covered caramels. The factory equipment can create chocolate-caramels of any size – and does so regularly. They can be as small as a pea or as big as a house. The company’s main problem is determining how much chocolate and caramel will be needed for a shipment. Fortunately, you can write a program that will solve this dilemma! Let's look at the type of candy you are creating: chocolate-covered caramels. Basically, these are spheres. However, there is a catch … Both the caramel center and the candy itself are spheres, but what exactly is the volume of the chocolate shell? It's definitely not the volume of a sphere with the full diameter. The center doesn't take up delicious chocolate… it is delicious caramel! You'll need to figure out how to compute the volume of the chocolate shell. Let's create a new function that will get us this value! 1. Add a new function 2. Give it a name – it's up to you. 3. For parameters, you want to pass in the total diameter of the larger sphere and the diameter of the internal sphere. Wait a sec! Didn't you already create a function for a sphere? Use that in your new function! 4. Using your existing sphereVolume function (you might call it twice), compute and return the volume of the shell. Now that you finished that. It's time to test it and make sure the values look correct! Testing is an important part of being a great computer programmer. 5. Modify your main program so you can type in 2 values – the outside diameter and the inside diameter. The pseudocode is below. I called my function sphereShell; replace this with whatever your function name is. Example Pseudocode Module main Declare Real d Declare Real i Input d Input i Display sphereShell(d, i) End Module 6 6. Execute your flowchart. Check your results with the table below. Outside Diameter Inside Diameter Volume 1 0.5 0.458148979166665 2 1 3.66519183333333 2 1.9 0.59742626883333 20 12 3284.01188266666 100 99 15551.4089488329 Did you get the correct results? If not double check your logic, your parameters, your data types etc…. Part 5 – Computing a Shipment Now that you can compute the volume of the caramel center (using the volume of a sphere function) and the chocolate shell (using your new function), you can finally make a program that computes orders! You going to compute the caramel and chocolate needed for a large for a shipment of candy. To accomplish this, you need to compute the required chocolate and caramel and store those values into variables. Then, you can multiply those values by the total number of candies that will be produced. 1. Select all the shapes in your main function 2. Delete them (they were just for testing anyway) 3. Declare real variables that will store the amount of chocolate and caramel in a single candy. 4. Declare real variables that will store the total amount of chocolate and caramel for the order.
Load more

Recommended publications
  • Multi-Return Function Call
    To appear in J. Functional Programming 1 Multi-return Function Call OLIN SHIVERS and DAVID FISHER College of Computing Georgia Institute of Technology (e-mail: fshivers,[email protected]) Abstract It is possible to extend the basic notion of “function call” to allow functions to have multiple re- turn points. This turns out to be a surprisingly useful mechanism. This article conducts a fairly wide-ranging tour of such a feature: a formal semantics for a minimal λ-calculus capturing the mechanism; motivating examples; monomorphic and parametrically polymorphic static type sys- tems; useful transformations; implementation concerns and experience with an implementation; and comparison to related mechanisms, such as exceptions, sum-types and explicit continuations. We conclude that multiple-return function call is not only a useful and expressive mechanism, at both the source-code and intermediate-representation levels, but also quite inexpensive to implement. Capsule Review Interesting new control-flow constructs don’t come along every day. Shivers and Fisher’s multi- return function call offers intriguing possibilities—but unlike delimited control operators or first- class continuations, it won’t make your head hurt or break the bank. It might even make you smile when you see the well-known tail call generalized to a “semi-tail call” and a “super-tail call.” What I enjoyed the most was the chance to reimagine several of my favorite little hacks using the new mechanism, but this unusually broad paper offers something for everyone: the language designer, the theorist, the implementor, and the programmer. 1 Introduction The purpose of this article is to explore in depth a particular programming-language mech- anism: the ability to specify multiple return points when calling a function.
    [Show full text]
  • Aeroscript Programming Language Reference
    AeroScript Programming Language Reference Table of Contents Table of Contents 2 Structure of a Program 5 Comments 6 Preprocessor 7 Text Replacement Macro (#define/#undef) 7 Source File Inclusion (#include) 8 Conditional Inclusion (#if/#ifdef/#ifndef) 8 Data Types and Variables 11 Fundamental Data Types 11 Fundamental Numeric Data Types 11 Fundamental String Data Type 11 Fundamental Axis Data Type 11 Fundamental Handle Data Type 12 Aggregate Data Types 12 Array Data Types 12 Structure Data Types 13 Enumerated Data Types 14 Variables 15 Variable Declaration 15 Variable Names 15 Numeric, Axis, and Handle Variable Declaration Syntax 15 String Variable Declaration Syntax 15 Syntax for Declaring Multiple Variables on the Same Line 16 Array Variable Declaration Syntax 16 Structure Variable Definition and Declaration Syntax 16 Definition Syntax 16 Declaration Syntax 17 Member Access Syntax 17 Enumeration Variable Definition and Declaration Syntax 18 Definition 18 Declaration Syntax 19 Enumerator Access Syntax 19 Variable Initialization Syntax 20 Basic Variable Initialization Syntax 20 Array Variable Initialization Syntax 21 Structure Variable Initialization Syntax 22 Enumeration Variable Initialization Syntax 22 Variable Scope 23 Controller Global Variables 23 User-Defined Variables 23 User-Defined Variable Accessibility 23 User-Defined Local Variable Declaration Location 25 Variable Data Type Conversions 26 Properties 27 Property Declaration 27 Property Names 27 Property Declaration 28 Property Usage 28 Expressions 29 Literals 29 Numeric Literals
    [Show full text]
  • The Cool Reference Manual∗
    The Cool Reference Manual∗ Contents 1 Introduction 3 2 Getting Started 3 3 Classes 4 3.1 Features . 4 3.2 Inheritance . 5 4 Types 6 4.1 SELF TYPE ........................................... 6 4.2 Type Checking . 7 5 Attributes 8 5.1 Void................................................ 8 6 Methods 8 7 Expressions 9 7.1 Constants . 9 7.2 Identifiers . 9 7.3 Assignment . 9 7.4 Dispatch . 10 7.5 Conditionals . 10 7.6 Loops . 11 7.7 Blocks . 11 7.8 Let . 11 7.9 Case . 12 7.10 New . 12 7.11 Isvoid . 12 7.12 Arithmetic and Comparison Operations . 13 ∗Copyright c 1995-2000 by Alex Aiken. All rights reserved. 1 8 Basic Classes 13 8.1 Object . 13 8.2 IO ................................................. 13 8.3 Int................................................. 14 8.4 String . 14 8.5 Bool . 14 9 Main Class 14 10 Lexical Structure 14 10.1 Integers, Identifiers, and Special Notation . 15 10.2 Strings . 15 10.3 Comments . 15 10.4 Keywords . 15 10.5 White Space . 15 11 Cool Syntax 17 11.1 Precedence . 17 12 Type Rules 17 12.1 Type Environments . 17 12.2 Type Checking Rules . 18 13 Operational Semantics 22 13.1 Environment and the Store . 22 13.2 Syntax for Cool Objects . 24 13.3 Class definitions . 24 13.4 Operational Rules . 25 14 Acknowledgements 30 2 1 Introduction This manual describes the programming language Cool: the Classroom Object-Oriented Language. Cool is a small language that can be implemented with reasonable effort in a one semester course. Still, Cool retains many of the features of modern programming languages including objects, static typing, and automatic memory management.
    [Show full text]
  • C Programming Tutorial
    C Programming Tutorial C PROGRAMMING TUTORIAL Simply Easy Learning by tutorialspoint.com tutorialspoint.com i COPYRIGHT & DISCLAIMER NOTICE All the content and graphics on this tutorial are the property of tutorialspoint.com. Any content from tutorialspoint.com or this tutorial may not be redistributed or reproduced in any way, shape, or form without the written permission of tutorialspoint.com. Failure to do so is a violation of copyright laws. This tutorial may contain inaccuracies or errors and tutorialspoint provides no guarantee regarding the accuracy of the site or its contents including this tutorial. If you discover that the tutorialspoint.com site or this tutorial content contains some errors, please contact us at [email protected] ii Table of Contents C Language Overview .............................................................. 1 Facts about C ............................................................................................... 1 Why to use C ? ............................................................................................. 2 C Programs .................................................................................................. 2 C Environment Setup ............................................................... 3 Text Editor ................................................................................................... 3 The C Compiler ............................................................................................ 3 Installation on Unix/Linux ............................................................................
    [Show full text]
  • Functions in C
    Functions in C Fortran 90 has three kinds of units: a program unit, subroutine units and function units. In C, all units are functions. For example, the C counterpart to the Fortran 90 program unit is the function named main: #include <stdio.h> main () /* main */ f float w, x, y, z; int i, j, k; w = 0.5; x = 5.0; y = 10.0; z = x + y * w; i = j = k = 5; printf("x = %f, y = %f, z = %f n", x, y, z); printf("i = %d, j = %d, k = %dnn", i, j, k); /* main */ n g Every C program must have a function named main; it’s the func- tion where the program begins execution. C also has a bunch of standard library functions, which are functions that come predefined for everyone to use. 1 Standard Library Functions in C1 C has a bunch of standard library functions that everyone gets to use for free. They are analogous to Fortran 90’s intrinsic functions, but they’re not quite the same. Why? Because Fortran 90’s intrinsic functions are built directly into the language, while C’s library functions are not really built into the language as such; you could replace them with your own if you wanted. Here’s some example standard library functions in C: Function Return Type Return Value #include file printf int number of characters written stdio.h Print (output) to standard output (the terminal) in the given format scanf int number of items input stdio.h Scan (input) from standard input (the keyboard) in the given format isalpha int Boolean: is argument a letter? ctype.h isdigit int Boolean: is argument a digit? ctype.h strcpy char [ ] string containing copy string.h Copy a string into another (empty) string strcmp int comparison of two strings string.h Lexical comparison of two strings; result is index in which strings differ: negative value if first string less than second, positive if vice versa, zero if equal sqrt float square root of argument math.h pow float 1st argument raised to 2nd argument math.h 1 Brian W.
    [Show full text]
  • Python 3 Types in the Wild:A Tale of Two Type Systems
    Python 3 Types in the Wild: A Tale of Two Type Systems Ingkarat Rak-amnouykit Daniel McCrevan Ana Milanova Rensselaer Polytechnic Institute Rensselaer Polytechnic Institute Rensselaer Polytechnic Institute New York, USA New York, USA New York, USA [email protected] [email protected] [email protected] Martin Hirzel Julian Dolby IBM TJ Watson Research Center IBM TJ Watson Research Center New York, USA New York, USA [email protected] [email protected] Abstract ACM Reference Format: Python 3 is a highly dynamic language, but it has introduced Ingkarat Rak-amnouykit, Daniel McCrevan, Ana Milanova, Martin a syntax for expressing types with PEP484. This paper ex- Hirzel, and Julian Dolby. 2020. Python 3 Types in the Wild: A Tale of Two Type Systems. In Proceedings of the 16th ACM SIGPLAN plores how developers use these type annotations, the type International Symposium on Dynamic Languages (DLS ’20), Novem- system semantics provided by type checking and inference ber 17, 2020, Virtual, USA. ACM, New York, NY, USA, 14 pages. tools, and the performance of these tools. We evaluate the https://doi.org/10.1145/3426422.3426981 types and tools on a corpus of public GitHub repositories. We review MyPy and PyType, two canonical static type checking 1 Introduction and inference tools, and their distinct approaches to type Dynamic languages in general and Python in particular1 analysis. We then address three research questions: (i) How are increasingly popular. Python is particularly popular for often and in what ways do developers use Python 3 types? machine learning and data science2. A defining feature of (ii) Which type errors do developers make? (iii) How do type dynamic languages is dynamic typing, which, essentially, for- errors from different tools compare? goes type annotations, allows variables to change type and Surprisingly, when developers use static types, the code does nearly all type checking at runtime.
    [Show full text]
  • The Grace Programming Language Draft Specification Version 0.5. 2025" (2015)
    Portland State University PDXScholar Computer Science Faculty Publications and Presentations Computer Science 2015 The Grace Programming Language Draft Specification ersionV 0.5. 2025 Andrew P. Black Portland State University, [email protected] Kim B. Bruce James Noble Follow this and additional works at: https://pdxscholar.library.pdx.edu/compsci_fac Part of the Programming Languages and Compilers Commons Let us know how access to this document benefits ou.y Citation Details Black, Andrew P.; Bruce, Kim B.; and Noble, James, "The Grace Programming Language Draft Specification Version 0.5. 2025" (2015). Computer Science Faculty Publications and Presentations. 140. https://pdxscholar.library.pdx.edu/compsci_fac/140 This Working Paper is brought to you for free and open access. It has been accepted for inclusion in Computer Science Faculty Publications and Presentations by an authorized administrator of PDXScholar. Please contact us if we can make this document more accessible: [email protected]. The Grace Programming Language Draft Specification Version 0.5.2025 Andrew P. Black Kim B. Bruce James Noble April 2, 2015 1 Introduction This is a specification of the Grace Programming Language. This specifica- tion is notably incomplete, and everything is subject to change. In particular, this version does not address: • James IWE MUST COMMIT TO CLASS SYNTAX!J • the library, especially collections and collection literals • static type system (although we’ve made a start) • module system James Ishould write up from DYLA paperJ • dialects • the abstract top-level method, as a marker for abstract methods, • identifier resolution rule. • metadata (Java’s @annotations, C] attributes, final, abstract etc) James Ishould add this tooJ Kim INeed to add syntax, but not necessarily details of which attributes are in language (yet)J • immutable data and pure methods.
    [Show full text]
  • BTE2313 Chapter 7: Function
    For updated version, please click on http://ocw.ump.edu.my BTE2313 Chapter 7: Function by Sulastri Abdul Manap Faculty of Engineering Technology [email protected] Objectives • In this chapter, you will learn about: 1. Create and apply user defined function 2. Differentiate between standard library functions and user defined functions 3. Able to use both types of functions Introduction • A function is a complete section (block) of C++ code with a definite start point and an end point and its own set of variables. • Functions can be passed data values and they can return data. • Functions are called from other functions, like main() to perform the task. • Two types of function: 1. User defined function: The programmer writes their own function to use in the program. 2. Standard library function: Function already exist in the C++ standard libraries http://www.cplusplus.com/reference/ Introduction (cont.) • Advantages of functions: Easier to solve complex task by dividing it into several smaller parts (structured programming) Functions separate the concept (what is done) from the implementation (how it is done) Functions can be called several times in the same program, allowing the code to be reused. Three Important Questions • “What is the function supposed to do? (Who’s job is it?” ) – If a function is to read all data from a file, that function should open the file, read the data, and close the file. • “What input values does the function need to do its job?” – If your function is supposed to calculate the volume of a pond, you’d need to give it the pond dimensions.
    [Show full text]
  • Generics in the Java Programming Language
    Generics in the Java Programming Language Gilad Bracha July 5, 2004 Contents 1 Introduction 2 2 Defining Simple Generics 3 3 Generics and Subtyping 4 4 Wildcards 5 4.1 Bounded Wildcards . 6 5 Generic Methods 7 6 Interoperating with Legacy Code 10 6.1 Using Legacy Code in Generic Code . 10 6.2 Erasure and Translation . 12 6.3 Using Generic Code in Legacy Code . 13 7 The Fine Print 14 7.1 A Generic Class is Shared by all its Invocations . 14 7.2 Casts and InstanceOf . 14 7.3 Arrays . 15 8 Class Literals as Run-time Type Tokens 16 9 More Fun with Wildcards 18 9.1 Wildcard Capture . 20 10 Converting Legacy Code to Use Generics 20 11 Acknowledgements 23 1 1 Introduction JDK 1.5 introduces several extensions to the Java programming language. One of these is the introduction of generics. This tutorial is aimed at introducing you to generics. You may be familiar with similar constructs from other languages, most notably C++ templates. If so, you’ll soon see that there are both similarities and important differences. If you are not familiar with look-a-alike constructs from elsewhere, all the better; you can start afresh, without unlearning any misconceptions. Generics allow you to abstract over types. The most common examples are con- tainer types, such as those in the Collection hierarchy. Here is a typical usage of that sort: List myIntList = new LinkedList(); // 1 myIntList.add(new Integer(0)); // 2 Integer x = (Integer) myIntList.iterator().next(); // 3 The cast on line 3 is slightly annoying.
    [Show full text]
  • An Introduction to Programming in Java
    An introduction to programming in Java Paul Flavell and Richard Kaye School of Mathematics and Statistics University of Birmingham November 2000 These notes form a useful introduction to programming in Java as well as a reference guide for the second half of this term’s work and are based on notes produced by Paul Flavell for MSM2G5 in the academic year 1999–2000. You will find it helpful to re-read them later on in the term after you have had some experience of writing Java programs. 1 Introduction We only have time for a brief introduction to programming in Java. Much more information about Java is available in textbooks and on the web. A good place to find information on Java is the Sun website www.javasoft.com, in particular at www.javasoft.com/docs/index.html and the online tutorial at www.javasoft.com/docs/books/tutorial/index.html I encourage you to explore these sites. They provide a more expansive view of Java than the one I will be able to present in this short course. It is the intention that everything you need to know about Java for MSM2G5 will be contained in these notes and the notes given out in the computer labs that start in the sixth week of term. You may like to get one of the numerous books on Java, many of which are kept in stock at the large book shops in town and in the book shop on campus. However, as far as I know, there isn’t any book that is really suitable for this short course to mathematicians.
    [Show full text]
  • AP Computer Science a Study Guide
    AP Computer Science A Study Guide AP is a registered trademark of the College Board, which was not involved in the production of, and does not endorse, this product. Key Exam Details The AP® Computer Science A course is equivalent to a first-semester, college-level course in computer science. The 3-hour, end-of-course exam is comprised of 44 questions, including 40 multiple-choice questions (50% of the exam) and 4 free-response questions (50% of the exam). The exam covers the following course content categories: • Primitive Types: 2.5%–5% of test questions • Using Objects: 5%–7.5% of test questions • Boolean Expressions and if Statements: 15%–17.5% of test questions • Iteration: 17.5%–22.5% of test questions • Writing Classes: 5%–7.5% of test questions • Array: 10%–15% of test questions • ArrayList: 2.5%–7.5% of test questions • 2D Array: 7.5%–10% of test questions • Inheritance: 5%–10% of test questions • Recursion: 5%–7.5% of test questions This guide provides an overview of the main tested subjects, along with sample AP multiple-choice questions that are similar to the questions you will see on test day. Primitive Types Around 2.5–5% of the questions you’ll see on the exam cover the topic of Primitive Types. Printing and Comments The System.out.print and System.out.println methods are used to send output for display on the console. The only difference between them is that the println method moves the cursor to a new line after displaying the given data, while the print method does not.
    [Show full text]
  • C Programming Basics
    C Programming Basics Ritu Arora Texas Advanced Computing Center November 7th, 2011 Overview of the Lecture • Writing a Basic C Program • Understanding Errors • Comments, Keywords, Identifiers, Variables • Standard Input and Output • Operators • Control Structures • Functions in C • Arrays, Structures • Pointers • Working with Files All the concepts are accompanied by examples. 2 How to Create a C Program? • Have an idea about what to program • Write the source code using an editor or an Integrated Development Environment (IDE) • Compile the source code and link the program by using the C compiler • Fix errors, if any • Run the program and test it • Fix bugs, if any 3 Write the Source Code: firstCode.c #include <stdio.h> int main(){ printf("Introduction to C!\n"); return(0); } 4 Understanding firstCode.c Preprocessor directive Name of the standard header #include <stdio.h> file to be included is specified within angular brackets Function’s return type Function name Function name is followed by parentheses – they int main(){ can be empty when no arguments are passed printf("Introduction to C!\n"); C language function for displaying information on the screen return(0); Keyword, command for returning function value } The contents of the functions are placed inside the curly braces Text strings are specified within "" and every statement is terminated by ; Newline character is specified by \n 5 Save-Compile-Link-Run • Save your program (source code) in a file having a “c” extension. Example, firstCode.c • Compile and Link your code (linking
    [Show full text]