Has PB a ByRef like VisualBasic?

[electrochrisso]

I think the PB manual gives a great compromise between functionality and information overload. It gets you up and running and from there you choose your own path; whether that involves more reading or rolling your sleeves up and throwing down some code. No, too many language guides simply throw too much unnecessary information your way. Personally I love the PB user manual.

I'm with you srod.
Anyway, the PB forum fills all of the gaps, the PB manual leaves out.

[Thorium]

Some people say PB is the C of the Basics. And i think it's true. It does not offer some stuff like ByRef/ByVal, no OOP. But it shines if you need to go low level.

Once you got used to it, you will not miss ByRef/ByVal. You will use pointers anyway, to make your code faster and more elegant, so using pointers for passing parameters is just convenient. I think it matches the style of PB. Because what you realy do if you pass a string ByRef is: You pass a pointer to a pointer that points to the string. And that is how you code it in PB.

[FromVbToPb]

… Sorry for all this text here, don't take it al a attack or criticism. This here is not about ByRef any more, but about polishing work in general. (text all the time sound a bit harder then they are meant, so see me smiling if you want read this all)




Discussions like "i have never use this function" or "i never miss this option" makes must of the time not much sense. i want paint me house green and ask for green color, and every body whit a white houses tell mi, "i never needed green color, so why you?". “because i like to have a green house.” “Why? I don't” “because i like green” “i don't, why you don't mix blue and yellow, or use red, but we have no blue and red too, so whats wrong with white?”..... so .... we end up in a dead end discussion of opinions.
Simply, i don't like extra work and workarounds, i like beautiful polished things, and want to see if the PB team likes this too. This was the reason for choosing Basic instead of C or Pascal a the first place long time ago. (And Basic was and is weaker then C, not because it is a nature law or a syntax limitation, it simply never got the deserved attention. Maybe it is a go along to get along, accept and adapt the giving problem, i don't know.)



BorisTheOld:

We like to make our code as self-documenting as possible: highly structured, rigid naming rules, and no "tricky" code. Unfortunately, PB requires some "tricky" code to implement a ByRef feature. It also requires some "tricky" code to pass structures to a procedure.

By "tricky" code, I mean code that is not immediately obvious to a non-expert programmer.

Exactly! “We like to make our code as self-documenting as possible” me to! So simple a s possible, no useless "tricky" code pleas. Like a mathematician i tray to reduce everything on the most simple self -explaining result.
i don't like double work, and i don't like nonsense like ;;;;;;{}<bla>{->{{;;}::}}{::};;{{.}};{};{} in C, or "a_end_block_is_coming_soon, the_end_block_is_now_near, this_is_now_the_end_block_here, the_end_block_ends_here, this_was_the_endblock_and_a_new_is_maybe_coming_soon", blablablablablabla stuff of pascal, only a other ;;;;;{} mess only more useless text. And workarounds are the same mess.

Sometimes if i want say that something is useless stupid boring extra-work frustrating flub, i write ;;;;;;;;;;;;;;;;;;;;;;; (amount of ; indicating the frustration level )

The Macro tricks is a good tip and i use macros already and macros is a big extra in PB!
but i don't want do such extra work all the time on many many places. this permanent workarounds is not "non-expert programming", it is extra work witch compilers has to take this away from programmers. "expert programming" is often a cheap excuse from developers.
i am a very good workarounder, because i all the time tray to find a solution do polish that what others don't polish (as a example what perfectionism can by, i would like to write all Names in the same alphanumeric sortable class.like order, for example IfEnd or ProcedureEnd or FileOpen, (first the main topic), my code names looks like this. i have already prepare a list of macros to do this in PB, so crazy i am in polishing and bending things to me likes.) i am wiling to do this ByRef corrections, but i don't like. thats why i am asking, to see if the developers are willing to do the polishing.
The only reason to give PB a tray is almost all problems can be work arounded in some way. But i search the most "aerodynamic" beautiful developer language i can find. And a I am very suppressed that in decades of computer existence, there is non?!

And tanks much BorisTheOld for the example, it speeds up me workaroundings and my understanding of how PB deals with Pointers.
but all this work around never make it possible that you can change only 1 little option, and thats it, all this typical workarounds needs useless time, the compiler has to "reduce the clutter". I like convenience. Compilers are a kind of engineer work, (just not physical and allow therefore more flob then mechanics and electronics). And you like to have a car witch is not only rolling, but is aerodynamic and looks good in your favorite color. Al programmers spend a LOT of time with there compiler and main language, sure much more then in there cars.



"non-expert programmer" hmmm.... this is what many developers sometimes say, if they flubworked unnecessary complexitys together, and then blaming the uers if they complain about the extra work and then say "it is only for experts" or in bad cases this means “if you would be a expert and not a idiot/lazy-beginner, you would know haw to deal whit it, so do you workarounds and shut up”.
Missing ByRef is not a "non-expert programmer", but a polishing problem of the developers side. Experts only know the workaround witch should not be necessary at the first place.
{{
The best thing i read once in a Linux forum when somebody complains about a useless complexity and unlogik. Answer of one of a Forum-Guru there, Quot: "Linux is not for everybody". a OS system, witch tray to make concurrence to M$, with now user friendly graphic desktop, not Server software any more, a lot of good stuff done,... is not a for everybody???! good marketing!! Desktop operating systems are the ONLY software witch hast to be for everybody to reach the goal. Otherwise they are hardware drivers like a server software. What a excuse for flubwork.... only because its free, it should not be a excuse for bad work. I am willing to pay something, specially if i use something commercially, if the price is fair and the product good. (shame on commercial users witch don't support the developers of there tools, and more richer more greedier and stingier, right?!) To Lunix-Gurus, don't complain then too if projects die or remain small, split up in hundred pieces, or never get the attention they deserve because of a lot of good stuff and good work in the base, but not polished enough. And then comes the excuse, is for free and you don't have to use it... ok...
It is simple, a team of developers hat do work a problem out, or they multiplicate it a 100'000 maybe 1'000'000 time to there users witch all of them have to create workarounds and deal whit permanent frictions, and then others can to work in formus and support (nice if you make our money with “free” software with the support, then there is no really interest for simplicity.)
If people would understand, lifetime is the must precious thing we have, much more then money, DON'T WAST IT, you have less then 100 years to live. And everybody knows: “Linux is for free if your time has no value”... sad...
I tray 3 times in 5 years periods to switch from M$ to Linux, i still have to scarify to much, and there is cool stuff in Linux!
}}




It seams that most progrannmers have not a very good aesthetic talent, especially not if they hang out to long in C. There is a reason why some people don't use the power of C++ C# and the BIG amount of free codes and compilers out there, and use instead a Basic language witch many people see as unprofessional Hobby language, even if this is not a Syntax but a code and polishing problem. i remember whit abomination the first Borland C compilers, and I DON'T WANT DO CODEING LIKE THIS EVER AGAIN!!! I am a aesthetic, and this pains me brain and my eyes.
i check even Lazarus, a Pascal/Delphi compiler, with a very nice From editor, powerful, open Source, Free and a big community, and ... ähmm ... noup! (Pascal blablabla Code, and this monster witch comes whit over 17'000 files, produces for "Halo World" megabytes of codes.) i don't even come to the idea to write a question in there forum, there project, so nice it is, don't fit with my needs likes and dislikes.
RealBasic: No. nice start but buggy as hell, the users run away from the project and forums (the forum is almost empty) and some regret to spend money for it.
PowerBasic: hmmm.. nice syntax, better then PB in some things like Var&Var&& even if i prefer Var&1 Var&2 Var&4 or Text$1 Text$2 or Var#8, i like this! but to old fashion, i don't code for DOS, and i am a visual person, and the most programs (god tangs) today too. I spend so much time in polishing me codes, that i will never use 10 languages, 2 is acceptable but not optimal (maybe PB and VB6 or something else beside VB6).
KBasic: Nice surface and "on paper" 100% VB6 compatible. but almost dead, no updates since 2010, and buggy as hell.
FreeBasic: Nice but to weak.
etc etc etc..... (i am e bit frustrated, we you folks all out there dint work together and make the pest compiler possible... just kidding!)
M$ is really not a nice company, and VB6 was a weak toy language with a lot of weaknesses (no unsigned (really?!), no pointers, no better OOP, no DLL independence, COMMON!!!!! with quazilions of dollars they should get this done better!!!!!!!), but it had something all others don't have get to realize. they give to the users what they want and polished at least the flubwork the made. VB6 takes a lot of boring work away from the programmer, including the form editor and automatic generated events in it. this has “in trap” me too.


PB has (so much i know) only 2 or 3 coders, and they don't make enough money to work 100% on it, the progress therefore is slow. but at lest, PB is really OK for such a small project.
maybe i can not switch to PB completely. but maybe i use it for small Game development, if the multi platform thing works ... (i test this later).


There are other (not big but friction) problems with PB. it is a "1 pass compiler" so in some situations you have to declare functions. ok... i can life with this ... but i don't like this double work of declarations. the compiler should do automatically ALL the work he can, so that the programmer can concentrate on that what compiler can not do.

i now how it works if you want polished things (code artwork technologies or what ever). you have to infest 100% work to get all the stuff don witch is necessary to let is work. And then you infest a other 100% sometimes 200% 400% work for polishing purification and embellishment. but then you have something special and aerodynamic without useless friction. but i know, polishing is not that easy and quick like many people think. so me question here is, are the developers working on polishing and like to improve there really good work.

Part of the problem for new users is that the PB reference manual isn't rigorous in its explanations. We've spent a lot of time analyzing various language features and filling in the gaps in the reference manual. Things aren't always what they seem. Not that the manual is wrong. It's just that it often doesn't tell the whole story.

Way not making a Wiki for the help Texts, maybe even translations? maybe only for selected authors instead of all public, at least in the main text and open discussion sites public. maybe for a small payment for main authors working directly for the PB team, result based. It maybe takes work from developers witch better should write codes instead of help texts, mostly programmers don't like to write documentations.
I like help text short an compact, but complete.
(if things has to be explained long, the base is not well polished. Instead of explaining complexity, it has do be self-explaining. Make it more simpler, like implement ByRef instead of explaining workarounds, for example.)



As a tip for all developers
Programmers should work together with visual aesthetics, then the result look and feels much better. even if this seam to be a detail, it is that what produces every day all over useless friction. we are visual and not dead machine logic beings. and sometime i thing if people are to long in a ugly coder language, they thing and code ugly too. if the team or money is big enough, all the time employ somebody witch concentrate mainly or only on the design from a practical point of view, even the design of coder languages (c and pascal are design mess, maybe developed from asbergers, they have much less problems with such things because there “decoding system” works differed, but it is a very bad thing to let arbergers develop the design, they are good in logics ans precise, but not good visual and creative, i speculate).
If the PB team has no Designer, EMPOY ONE! even if it is only for 2 weeks. maybe you come up whit a much more beautiful an aerodynamic code for version 5.0.

A very powerful feature would be if PB had a Import-Corrector, witch means if something change on the syntax or names, PB would change or correct this to make it compatible to the new syntax. It would allow to update and purify PB without to trouble users whit hand made corrections. purify then became much less a problem and then inhibition is smaller. If now a update change names (for example function names, replace parameters), the Import-Corrector would change the code automatically, and inform the user about the changes. This would allow to improve PB even on Syntax level, without to trouble the programmers with the corrections. (VB still has this very very stupid ugly Instr([Start], Text, Search) parameter flub work. Whit a import corrector this error could be changed decades ago, without to trouble the programmers that match.)
You can pass the older version code through the parser, and instead of producing code you correct syntax and replace deprecated functions or improve syntax or parameter positions. If this corrector is powerful enough, it could even be used for transcoding languages in to PB, if PB understand other languages tokens. (At least 80% 90% of it, depend of the distance to PB)



And finally, i think PureBasic could be more known then it is now, it deserve more atention. Maybe polishing will get this done.





DON'T FEEL ATTACKED PLEASE!!!!! you was honest here.
And thangs very much to all here so far, it helped a lot of speeding up the PB understanding.
But now enough text. (sorry. but i am frustrated and would like to escape the VB6 dead end box in a acceptable way, and i wait now sooooooooo long.... I don't write so long texts again.) (you see, i am not lazy )




There is a other question remain, for the developers.
(i don't want infest time in a other dead end again)
Are you continuing to work on PB in next yeas? or if you give it up, do you make the project open source so that it can be continued from others?



Tanks very much so far.

[DarkDragon]

To read this I'll need weeks. Hopefully the pb team will read it faster so they can work on PB again this year. Fred reads a half and freak reads a half part.

[FromVbToPb]

i know in think, i was crazy enough to write it, and had to translate a lot word be word whit a dictionary........
i don't write so much again, i promise.
(i use reading (text to voice) software for such things.)

[srod]

At the end of the day people come into these forums and say things like "If only PB did this... or PB did that... then I would make good use of it!"

Well, PB is what it is. C is what it is. VB is what it is.

Use it if it suits your purposes. Use something else if it doesn't.

Simple.

[FromVbToPb]

The point is, the companies and projects which listen on this, are then maybe the most successful. You can never satisfy all wishes and desires, but some request shows you exclusive the points of improvements, and everybody in commercial projects develop for consumers, they are not god or king, but they are the goal. listen to them is smart.

i think my request is not a very outlandish idea. programmers seams to have problems in general to listen on consumers, more then engineers. maybe this is the reason why until now, there is no really really good language out there, only stuff which work some how, and then we all adapt and get along whit it... sad.

[skywalk]

~ and had to translate a lot word be word whit a dictionary........
i don't write so much again, i promise.
(i use reading (text to voice) software for such things.)

Ha, justs shows you how lacking the synthetic voice-to-text software is at subtleties.

Still, your thoughts and opinions are invaluable and some were downright comical.
Never stop writing or 'voice-to-texting' your experiences.
This is how a product evolves and one reason for this forum.
I too am put off by wordy syntax as it appears as un-designed or happenstance.
I really wish PB would choose a system and stick with it...
Noun-Verb -> StringFind() instead of Verb-Noun -> FindString().
Then AutoComplete could reduce the need for a Help File.
I would just type String... and all the String Functions would pop up.

Most constants are structured and named with a purpose, then so should the keywords!
'#PB_Event_...'

It would be awesome if AutoComplete would present all 'Gadget' leading keywords or 'String' functions or whatever.
Instead there are mixing of all and new users must jump through trial and error and head to the Help.
Eventually, this becomes moot as it moves into your muscle memory, but again, talking about new users or looking at code from a year ago.

rant off

[srod]

...maybe this is the reason why until now, there is no really really good language out there, only stuff which work some how, and then we all adapt and get along whit it... sad.

Oh, I think there are a lot of people who will disagree with that. I think PB is a great language, but then there are certain things I would not use it for.

It's all a matter of personal opinion really. Missing a BYREF facility doesn't make for a bad language inmo and having such a construct doesn't necessarily make for a great one. It's all swings and roundabouts. Personally I always found such a construct cumbersome and one I didn't like. With pointers you know when you are dereferencing an address. With BYREF I would often forget that I was modifying the original value etc.

At the end of the day you make do. Compared to other requests regarding additions to PB, I can't really remember BYREF being one requested too many times; certainly not one with much in the way of a vociferous backing - not like OOP anyhow! Beside's there have been plenty of things added to PB following repeated requests (e.g. arrays/lists/maps in dynamic structures etc.) so, well, you never know!

No, Fred and co. work miracles as it is given the number of platforms they support.

[IdeasVacuum]

I think the best advice has already been given - maintain your current projects in VB.

If you want to build new projects with a different, current language, Pure Basic is certainly worth considering since it has many strengths, few weaknesses and one of (if not the) best forum communities around. For my purposes, PB is the best.

[BorisTheOld]

Well, PB is what it is. C is what it is. VB is what it is.

Use it if it suits your purposes. Use something else if it doesn't.

PB suits my purpose very well. And with the help of your OOP tutorial we are able to make our PB programs look just like VB.

Our classes have built-in reference counting, auto destruction of instances, auto gadget resizing, and all the messy details of event handling are done automatically within the classes. VB-like callback routines are used to invoke user code. And yes, we even have "call by reference".

All this is done using PB's standard cross-platform features. No Windows or Linux API code is used.

Here's a snippet from a typical application:

Code: Select all

;===============================================
;
;  dvs00dd.pb  :  DVS Data Dictionary
;
;===============================================
;  Compiler Directives
;-----------------------------------------------
;
  EnableExplicit
;
;===============================================
;  Include Files
;-----------------------------------------------
;
;  primary macros, constants, and structures
;
IncludeFile "modMacro.pbi"                                      ; Global Macros
IncludeFile "modConstant.pbi"                                   ; Global Constants
IncludeFile "modStructure.pbi"                                  ; Global Structures
;
;  classes
;
IncludeFile "clsApplication.pbi"                                ; application class
IncludeFile "clsPanel.pbi"                                      ; generic container class
IncludeFile "clsSplitter.pbi"                                   ; splitter class
IncludeFile "clsMenu.pbi"                                       ; menu class
IncludeFile "clsMenuItem.pbi"                                   ; menuitem class
IncludeFile "clsTabbedPanel.pbi"                                ; tabbed panel class
;
;===============================================
;
;  Mainline
;

  Global proApp.objApplication                                  ; application object
  Global proAppPanel.objPanel                                   ; primary application panel (window)

  proApp      = clsApplication()                                ; create the application instance
  proAppPanel = clsPanel()                                      ; create the primary panel instance
  
  proAppPanel\setoApp(proApp)                                   ; link the primary panel to the application
  proAppPanel\setiPanelType(#iPANEL_TYPE_APPLICATION)
  proAppPanel\setsCaption("DVS Data Dictionary")
  proAppPanel\setiStartLocation(#iGUI_START_CENTRE)
  proAppPanel\setiWidth(1280)
  proAppPanel\setiHeight(800)
  proAppPanel\setpAppStart(CodePtr(subAppStart))
  proAppPanel\setpAppStop(CodePtr(subAppStop))
  proAppPanel\setpAppDesign(CodePtr(subAppDesign))
  proAppPanel\subAttach()                                       ; attach the primary panel to the application 
  
  proAppPanel\subDestroy()                                      ; destroy the primary panel instance
  proApp\subDestroy()                                           ; destroy the application instance

End
;
;===============================================
;
Procedure subAppStart()                                         ; perform application setup

;  non-GUI application setup code goes here

EndProcedure
;
;===============================================
;
Procedure subAppStop()                                          ; perform application shutdown

;  non-GUI application shutdown code goes here
  
EndProcedure
;
;===============================================
;
Procedure subAppDesign()                                        ; design the application window

  Global proMain.objSplitter                                    ; main splitter object

  proMain = clsSplitter()                                       ; create the main splitter instance
  
  proMain\setoParentPanel(proAppPanel)
  proMain\setiSplitterStyle(#iSPLITTER_STYLE_HORIZONTAL)
  proMain\setpMainDesignLeft(CodePtr(subMainDesignLeft))
  proMain\setpMainDesignRight(CodePtr(subMainDesignRight))
  proMain\subAttach()                                           ; attach the main splitter to the primary applictaion panel

EndProcedure
;
;===============================================
;
Procedure subMainDesignLeft()                                   ; design the left panel of the main splitter

  Global proMenu.objMenu                                        ; menu object (implemented as a treeview)

  proMenu = clsMenu()                                           ; create the menu instance
  
  proMenu\setoParentPanel(proMain\getoPanelLeft())
  proMenu\setpMenuDesign(CodePtr(subMenuDesign))
  proMenu\subAttach()                                           ; attach the menu object to the left splitter panel

EndProcedure
;
;===============================================
;
Procedure subMainDesignRight()                                  ; design the right panel of the main splitter

  Global proTabs.objTabbedPanel                                 ; tabbed panel object (contains all app windows & gadgets)

  proTabs = clsTabbedPanel()                                    ; create the tabbed panel instance
  
  proTabs\setoParentPanel(proMain\getoPanelRight())
  proTabs\subAttach()                                           ; attach the tabbed panel object to the right splitter panel
  
EndProcedure
;
;===============================================
;
Procedure subMenuDesign()                                       ; design the menu 

  Global proMenu001000.objMenuItem
  Global proMenu001001.objMenuItem
  Global proMenu001002.objMenuItem
  Global proMenu002000.objMenuItem
  Global proMenu002001.objMenuItem
  Global proMenu002002.objMenuItem
  Global proMenu002003.objMenuItem
 
  proMenu001000 = clsMenuItem()
  proMenu001000\setiMenuType(#iMENU_TYPE_HEADING)
  proMenu001000\setiMenuHeadingState(#iMENU_HEADING_EXPAND)
  proMenu001000\setoMenu(proMenu)
  proMenu001000\setsCaption("Common")
  proMenu001000\subAttach()
  
  proMenu001001 = clsMenuItem()
  proMenu001001\setiMenuType(#iMENU_TYPE_TOPIC)
  proMenu001001\setoMenuHeading(proMenu001000)
  proMenu001001\setsCaption("Log In")
  proMenu001001\setpMenuItemClick(CodePtr(subMenu001001Click))
  proMenu001001\subAttach()
  
  proMenu001002 = clsMenuItem()
  proMenu001002\setiMenuType(#iMENU_TYPE_TOPIC)
  proMenu001002\setoMenuHeading(proMenu001000)
  proMenu001002\setsCaption("Quit")
  proMenu001002\setpMenuItemClick(CodePtr(subMenu001002Click))
  proMenu001002\subAttach()

  proMenu002000 = clsMenuItem()
  proMenu002000\setiMenuType(#iMENU_TYPE_HEADING)
  proMenu002000\setoMenu(proMenu)
  proMenu002000\setsCaption("Maintain Database")
  proMenu002000\subAttach()
  
  proMenu002001 = clsMenuItem()
  proMenu002001\setiMenuType(#iMENU_TYPE_TOPIC)
  proMenu002001\setoMenuHeading(proMenu002000)
  proMenu002001\setsCaption("Data Elements")
  proMenu002001\setpMenuItemClick(CodePtr(subMenu002001Click))
  proMenu002001\subAttach()
  
  proMenu002002 = clsMenuItem()
  proMenu002002\setiMenuType(#iMENU_TYPE_TOPIC)
  proMenu002002\setoMenuHeading(proMenu002000)
  proMenu002002\setsCaption("Logic Rules")
  proMenu002002\setpMenuItemClick(CodePtr(subMenu002002Click))
  proMenu002002\subAttach()

  proMenu002003 = clsMenuItem()
  proMenu002003\setiMenuType(#iMENU_TYPE_TOPIC)
  proMenu002003\setoMenuHeading(proMenu002000)
  proMenu002003\setsCaption("Structures")
  proMenu002003\setpMenuItemClick(CodePtr(subMenu002003Click))
  proMenu002003\subAttach()

EndProcedure
;
;===============================================
;
Procedure subMenu001001Click()

;  process the menuitem click event

EndProcedure
;
;===============================================
;

etc, etc

;
;===============================================
;  End of dvs00dd.pb
;===============================================