What is Reddit's opinion of Silex PHP micro-framework?

From 3.5 billion Reddit comments

For the first 3, I would recommend the Symfony HTTP Foundation component (https://github.com/symfony/HttpFoundation). It used by many different frameworks so you know it's well supported. It allows you to access all the superglobals use an entity called a ParameterBag which makes it easy to specify defaults when retrieving values. It utilizes the PHP filter_var function when using $request->$request->filter().

// Set up the object $request = Request::createFromGlobals(); // Get the email value from the $_POST, but set as 'NA' if not found $email = $request->request->get('email', 'NA');

For complex validation, take a looks at the Symfony and Silex Validator. They allow you to create assertions to ensure the data you get is acceptable: http://silex.sensiolabs.org/doc/providers/validator.html.

If you building small website (especially heavily depended on API), try Slimframework. Another lightweight is Silex, witch is small framework from Symphony components.

Have a look at:

Silex: Symfony components "Silex is a PHP microframework for PHP. It is built on the shoulders of Symfony and Pimple and also inspired by sinatra."

http://silex.sensiolabs.org

Lumen: Laravel based "The stunningly fast micro-framework by Laravel"

https://lumen.laravel.com

Also look at the microkernel for Symfony: http://symfony.com/doc/current/configuration/micro_kernel_trait.html

Whats your reason for "no framework"? Hard to help you without requirements.

You can use the Symfony Routing component without the full stack framework: https://github.com/symfony/Routing

Or maybe take a look at Silex: http://silex.sensiolabs.org/

You might also be interested in Silex. It's still a framework, but it's a "micro" framework that comes with exceedingly little out of the box. It's compatible with a lot of great libraries, and it lets you totally control the structure of your application. You learn a lot by wiring it all together. Here's a helpful blog post about structure etc.

I like to do something like:

/app /controllers /views /src (for my custom libraries - PSR-0 or PSR-4 (I never remember which) stuff) /MyAppNamespace /Repos /Services / .... whatever else! /vendor /public /js /css /img

But really you can do however you like.

First off, my condolences. I've been dealing with almost the same exact thing. I hope your stored procedures are designed better than some of ours.

What we've done is abstract the functionality out of the procedural code and make each area its own class. I think the hardest part is categorizing the stored procedures and getting a better abstraction on the overall functionality. E.g. spGetUser with spFindUser or spGetPrivateMessages - how far do you abstract functionality.

Other things have been done to reduce the legacy code. We've wrapped Silex around the legacy application which gives us the power of pimple and routing (for writing new, oop code). Basically the legacy app gets routed and called via a legacyController function which can inject the service container into a global variable (stored in $GLOBALS) so you can start using newer tools.

Silex sounds like a good bet, when combined with Doctrine it'll be able to use any common DB and the documentation is good. If you need more modules you can just pull in components with composer.

http://silex.sensiolabs.org/

Honestly most projects -- in my personal opinion -- do not need a full stack framework like symfony, zend or laravel. I would look more into smaller frameworks such as slim or perhaps silex aka mini symfony. There is also aura v2 packages which is less a framework and more a collection of framework like feature in separate packages that can be used independently or together.

I'd say make sure to identify the things you want your framework to do for you. Routing, session handling, maybe templating and logging. Create that list then check what does the chosen framework do for you. If it does a lot more than you might be adding a lot of complexity for no reason. The reason I like the micro frameworks is it is simple to find a package via composer that does anything extra you want and just include it in your composer.json

If you do go with slim or silex the one thing that is a bit more difficult than the other frameworks is that because they are so flexible its hard to find tutorials on how best to set up your application. Their examples all have the entire application in a single file but I believe those are more to express the simplicity of the framework and is not recommend for anything of significant size.

Silex provides Symfony's security component - you could probably wrap that into whichever framework you're using. It takes care of authentication and authorization, and seems pretty easy to connect to different user providers (db, static, etc.)

1. Use Composer
2. From #1, autoloader.php doesn't need to exist
3. json.php doesn't need to exist
4. requesthandler.php / responsehandler.php should use existing (tested) components. See Symfony HTTPFoundation for an example. (If you have custom needs, extend HTTPFoundation or comparable components)
5. methods.php should be split out and organized...this is equivalent to having "functions.php" and that gets nasty real quick
6. pdosingleton.php shouldn't exist, there are better ways to manage a connection
7. If you're going to request community comments, please have documentation (both README and docblock comments)
8. Look at something like Silex or Slim. They're doing what this appears to be doing, but following better practices

> My opinion may be based on old information and maybe things have changed and I need to reevaluate my opinion.

I think you hit the mark there. The first part sounded to me like NIH syndrome, but I understand where your sentiment comes from: up until a few years ago, most framework forced you into working a specific way. Those days are long gone. With composer and re-usable components, the era of framework-less frameworks has begun.

Basically nowadays everyone kinda just puts all the stuff they want together, and in that way create their "own" custom framework.

Then there are minimal approach frameworks (so called micro-framework) that just give you a bare minimum skeleton, and take away the tedious job of wiring everything together (take a look at Silex, Slim or the fancy new middleware approach called Expressive

The question begs: what to you defines a framework. Most micro frameworks are basically:

• a Router (map url to X)
• a Request/Response handler (using the SF2 HttpFoundation or the PSR Interfaces all the frameworks that use this can basically work together... kinda)
• a Dependancy Injection Container (if class needs Foo, give it Foo)

It doesn't get more bare metal than this most of the time, and tbh writing these are tedious, so why re-invent the wheel ;-)

I have concluded that you cannot truly appreciate all that frameworks do for you until you have had to go back to "native."

I have landed on Symfony as my go to for my projects, but if I have something small that I want to bang out then I fall back to Silex, which also uses Symfony components.

If security is your primary concern then go Symfony. If you feel the need to have complete control then go Silex.

Flask is great, there's a number of PHP microframeworks quite similiar. One is Silex which is built using Symfony components, very stable. If you liked the look of Laravel there is also a microframework made by the same guys called Lumen. I'd recommend checking both out. Unfortunately this sub is full of people that will just tell you not to use X and to use their favourite tool instead, so ignore anyone that recommends you use Wordpress or Drupal or a framework in another language. PHP has plenty of neat little frameworks, have a look around.

It's hard to say without knowing your full use case, but this seems like it would be best handled by one of two more appropriate pieces of functionality:

• Route variable conversion
• Route requirements

You can build a strotolower converter if you want to accept any cased argument, or you can define regular expression requirement that forces the route parameters to be lower case, rejecting anything that isn't 100% lower case.

So while you can use middleware here, it might be more "silex-y" to use converters or requirements.

We asked ourselves the same question. And eventually went with an entirely different approach: I mean we go through all this trouble just to have a SPA and reinvent everything which is already existing in the browser: URLs, dynamic asset loading etc etc.

So we basically ditched the SPA idea and and used a backend framework to do the routing where different pages load different parts of the application. Sure it is no longer a SPA, but in return I don't have to worry about routing, history, asset loading etc.

This is by no means the be-all / end-all, it is just a different way of utilizing Angular which is working out great for our use case.

You can set up a automatic generated token in a hidden input on the form and store it too on the session. On the php script that receives the post you check if the session token matches the hidden input.

This is a common security breach. I recommend that you use a simple framework, like silex, it's FormServiceProvider have a CSRF token that automatic protect you against this kind of attack.

I also recommed you take a read at the top 10 common attacks and search how to protect your website.

Silex >Silex is a PHP microframework for PHP 5.3. It is built on the shoulders of Symfony2 and Pimple and also inspired by sinatra.

Great documentation, I use it all the time for my projects.

It should be the same as any other project. Edit your host file and add the site in m/xamp like you would normally, and specify /full/path/to/project/folder/web as the document root. Add an .htaccess file in the web directory as found here.

I am completely self taught. It mostly comes down to experience and a lot of time spent with Google. When one gets to the point of working with MVC frameworks, I advise people to spend time learning design patterns, which are basically common ways to solve common problems. That will give you a lot of insight into how a framework works and why it was designed a specific way. MVC, front controller, observer, dependency injection and repository patterns are good ones to start with. Martin Fowler will be your friend here. As you learn about a concept, try implementing it.

If you want some exercises:

• Build your own framework
• Use Silex to create a site, using your best judgement on file/folder/class structure.
• Create a Composer package
• Create an plugin/module/extension/whatever for your favorite CMS (Bolt, WordPress, Drupal, etc)

The first time I started using APIs I did so using a microframework, and for this use they're a great option.

I'd recommend Silex, based on Symfony, or Lumen, the equivalent for Laravel. They're a good toe in the water of a larger framework.

Both are excellent products, providing an entry point for their parent framework while also giving you an upgrade path if the application later needs it.

If you're familiar with C#, Ruby, or Python then you may be familiar with frameworks like Nancy, Sinatra, or Flask.

Two good frameworks that use a similar approach in PHP are:

• Slim Framework
• Silex
  

Also there is an ultra simple URL routing class called AltoRouter

In general, you want to take this basic URL routing approach and either attach your routes to functions, or classes with methods (i.e. controllers).

To send non-HTML output simply put the content you do want (i.e. json) into the response body.

As another poster mentioned, check out the json_decode and json_encode functions.

that's absolutely horrible guide:

1. it uses mysql_connect (deprecated in PHP 5.5, removed in PHP 7.0)
2. ripe for SQL injection (no prepared queries or even GET params sanitizing)
3. bad structured (many nested if/elses)

Please use sth like this instead:

• http://silex.sensiolabs.org/
• http://www.slimframework.com/

Advice from a PHP guy

To go alongside React/Angular which is JavaScript so works best with JSON I would suggest one of the following :

• Slim PHP
• Silex
• Symfony

All very good at creating RESTful solutions or just for spitting out JSON data as a response. They are lightweight and fast which also helps.

It all depends on the complexity of your project, if you need something stupid simple (so to speak) I would suggest SLim PHP as it just does what it is meant to. However if you need more complexity then go for Silex if you are good with PHP, else go for Symfony as it covers more of the application architecture for you.

Most people will suggest subscribing to Laracasts (Even for just a month) and reviewing some of the IoC lessons and service providers. The documentation isn't that great for service providers if you don't know what you're doing.

I actually found reading some of the Silex documentation to be helpful, specifically the documentation on services. Silex is a slimmed-down version of Symfony and Laravel draws heavily from Symfony components.

If you can wrap your head around the idea that you're registering a service to an $app instance, then you're on your way to understanding Service Providers :)

IMO if you use DI you should register Twig or a default template engine and allow users to define and register their own service containers if they want to use another engine, like Silex does :)

http://silex.sensiolabs.org/doc/providers.html

As /u/canadiancreed mentioned, Wordpress is built using PHP, so if you're doing a comparison like that, then you should potentially take /u/klatar's advice and do a lot of research to get a framework/software shortlist. Actually, do this anyway, having an idea of what else is out there is always a good one. One thing I will say though, Wordpress is brilliant for its intended purpose, blogging. Once you start adding functionality that takes it away from this then you need to use something else. I've never had a good experience with non-blog websites powered by Wordpress, so my advice would be to keep clear from it.

If you, or your friend is still considering building the site in PHP, then it may be worth looking at Silex as it's really good for mocking up applications, so you could potentially get a proof of concept, then pick something more suitable. If you don't want to write too much code, then I may also suggest Drupal. Getting a base installation up and running takes a fair few modules, but once you're at that stage you can build applications quite quickly, the problem only comes when you want to do something non-Drupal, or some heavy customisations, but I'm guessing this wouldn't be your intention.

I hope something helps, I do tend to ramble.

Bolt is built using Silex I believe, which is one of the items that I have been looking into recently for small projects.

So not only is there documentation for Bolt, you can read about the Silex documentation as well.

I love Symfony. There are many reasons, but mostly it comes down to preference. Symfony uses patterns and coding standards that I use-- when I look at Symfony's code it makes sense. Very seldom am I sitting there looking at something and saying 'wtf?' Obviously, there are other reasons....

Pros:

• Very popular and very active. You can often times see the core developers respond on the mailing lists and they are nearly always on IRC.

• Good use of well-established patterns. As I said above, at least for me, this leaves me feeling good about things when I dig into Symfony core code to see how things work. It makes sense.

• Extremely flexible. If you find that you don't need the entire Symfony stack, you can pick and choose components and put them together in your own custom stack of components. A good example of this is Silex.

• Extremely flexible part two. You will have a pleasant time trying to integrate legacy components or third party (non Symfony) libraries because all it will usually take is a little bit of boiler-plate code to get Symfony and your libraries co-operating. Usually.

Cons:

• The entire 'Symfony Standard' stack is very large.

• It can be very complex.

• As noted, they aren't exactly afraid of doing backwards-compatibility breaking changes which is what is happening with the 2.1 release. This can also be argued as a pro since it means that they aren't afraid to fix bad design decisions.

• It is one of the slower frameworks, though with a little bit of optimization this is hardly an issue.

For small/medium-sized projects you might want to have a look at Silex as well: http://silex.sensiolabs.org/

It's build by the same people, using the same components, it's MUCH simpler to start working with and you can migrate easily to Symfony2 if your project grows a lot.

I'm not so sure you really have the concept of a dependency injection container down.

$this->hooks = $this->di->get('hooks'); $this->router = $this->di->get('router'); $this->plugin_manager = $this->di->get('pluginManager'); $this->pdo = $this->di->has('pdo') ? $this->di->get('pdo') : -1;

There is no reason for most of the private properties in your app class. Especially pdo. Pdo should be injected (by the container) into whatever classes need them. Storing it as a property makes little sense. Same for the other ones. Pull them out when you need them.

Maybe take a look at Silex just to get a slightly different perspective on populating and using a container. Slim is also a good framework to review.

When starting out with Routing, have a look at Silex. It's my go-to router, sensiolabs has abundant documentation and there's loads of tutorials online using Silex.

Since I'm writing APIs all the time, I've been using a lot of micro frameworks lately. For a smaller project, I'd advice you to use something like Slime, an awesome micro framework that have easy learning curve. Full REST support of course. I can't advice you Lumen because I never tried it but I heard really good thing about it so you may check that out. Afaik, it's born out of Laravel and their ecocycle, preferable for a bigger project.

You may aswell try Silex, it's lightweight and offers customization based on Symfony components. Not my type of choice but it's something you may find yourself in.

Sounds like you need to start down low with the fundamentals. Codecademy is pretty good for the basics (variables, control structures, etc): https://www.codecademy.com/learn/php.

Once you're having fun with PHP there, I like to direct people toward simple frameworks like Silex (http://silex.sensiolabs.org/) to learn some good best practices early on.

I would recommend to go with Silex. It has higher quality code, and it also has a benefit of being small enough, that a newbie can dig through it and have a hope in understanding how it works.

Or go with something like this: https://github.com/PatrickLouys/no-framework-tutorial

"The current Application is automatically injected by Silex to the Closure thanks to the type hinting."

Is injection simply mean Silex is passing/injecting a Silex\Application variable to the function?

http://silex.sensiolabs.org/doc/usage.html#dynamic-routing

If you want to "ease in" into Symfony development, why not start with Silex? It's a much less steep learning curve, but it uses most of the same components (like routing, twig, etc), and you'll get the hang of using composer.

http://silex.sensiolabs.org

Using framework is not strictly mandatory but it's recommended because if your project doesn't have a sound structure, the code will eventually spiral out of control. Especially if you are just starting to learn.

I'd recommend a micro framework like Slim or Silex since they both have good routers and useful helpers but most of the time they get out of the way of your own code.

Old PHP code is a nightmare to maintain. I'd say a rewrite would be good, but make sure you use a well-structured framework if you do so. Unless you are very confident you can do it right with something like Slim. Maybe give Silex a try? It's quite fun to work with and gives you a lot of freedom.

I do not know though how to convince yur boss :P

I dont have a trailing Slash...... interestingly - you can see What I am Talking about in Silex Homepage itself , see first go to this link - http://silex.sensiolabs.org/documentation ok you will get documentation, then try adding some 'blah' like this - http://silex.sensiolabs.org/documentation/blah you will get their 404 page, ok now remove 'blah' from url and hit enter, now your URL will be http://silex.sensiolabs.org/documentation but you wont get documentation instead you will be in 404 page.

The big two frameworks are Symfony and Laravel.

But all those reasons you listed are why I use Silex on one of my projects. http://silex.sensiolabs.org

It has a bit of a learning curve but you can organize your project however you want.

It does pretty much everything right out the box, but then you can also remove virtually any component and use an alternative instead. Perhaps not the best framework overall but if you really need that much control it might work for you.

Also you'll be wanting to use Composer as well probably.

> How is it that there are no frameworks designed around this paradigm?

Try Silex if that's what you want. No Controller classes necessary; just throw all your shit in anonymous functions, all in one big ass file.

Hint: This gets very unwieldy if you're not careful.

I know a person who did create restful service with symfony with angular. It worked out stable and well, but he knew his Symfony2 very well.

The thing is - learning Symfony is learning through book and cookbook, but yes, several months I think.

Silex is that thing that uses Doctrine, extensible, can be using Symfony bundles etc.

http://silex.sensiolabs.org/doc/usage.html

Normally custom frameworks are a cluster fuck, why rework something that has already been done 100x better?

> Its not hard to structure code and create SQL queries.

See stuff like this worries me, obviously you can do it correctly but working with raw SQL is never really ideal, why not just use an ORM such as doctrine.

> why do you need to outsource it to a generic framework thats fat and will expire?

So there are micro frameworks which it sounds like you would be interested in, see Silex.

As for frameworks expiring, it is a side affect but required for bug fixing and feature upgrading, major version changes are always problematic (Symfony 2 is massively different). If you were on Symfony 1.4 you would just stay on it.

You definitely do want some kind of framework (or server-side involvement), if only to increase the consistency between the pages. It gets old pretty quickly having to reflect a single common element's changed content across multiple pages.

PHP, for all its erstwhile faults, is a decent choice these days and a micro-framework like Silex could be a nice fit for you: powerful, extremely simple to set up / extend, good documentation.

http://silex.sensiolabs.org/

Pick and choose what you want from Symfony2. Extend at will. As for assets and images, check out Assetic, it'll do anything you want with images / css / js.

You should be able to roll a small CMS pretty quickly in it. I'm sure someone alreaday has.

[offtopic] CakePHP is a bad choice. Try Silex http://silex.sensiolabs.org/ — it's newer and much simplier. And when you'll start to feel comfortable with it, take a look at it's bigger brother Symfony2

I'm surprised Silex hasn't been mentioned. Great "micro-framework" for prototyping and small apps. Sismo is a great example of what you can do with Silex. https://github.com/fabpot/Sismo